70e34f7 Merge branch 'dev' · purego

M gen.sh +1 -1


@@ -18,4 +18,4 @@ echo "running a second pass for goimports..."
18		goimports -w v4	18		goimports -w v4
19			19
20		echo "running go vet..."	20		echo "running go vet..."
21	-	go vet ./v4/...	21	+	go vet -unsafeptr=false -stdmethods=false ./v4/...

M internal/core/core.go +17 -0


@@ -226,3 +226,20 @@ func GoString(c uintptr) string {
226	}	226		}
227	return string(unsafe.Slice((*byte)(ptr), length))	227		return string(unsafe.Slice((*byte)(ptr), length))
228	}	228		}
		229	+
		230	+	// NullableStringToPtr converts a nullable Go string to a uintptr suitable for C calls.
		231	+	func NullableStringToPtr(s *string) uintptr {
		232	+	if s == nil {
		233	+	return 0
		234	+	}
		235	+	return uintptr(unsafe.Pointer(CString(*s)))
		236	+	}
		237	+
		238	+	// PtrToNullableString converts a nullable char* to a Go *string (nil when NULL).
		239	+	func PtrToNullableString(ptr uintptr) *string {
		240	+	if ptr == 0 {
		241	+	return nil
		242	+	}
		243	+	str := GoString(ptr)
		244	+	return &str
		245	+	}

M internal/gir/pass/pass.go +105 -26

 				Name:  util.ConstructorName(c.Name, rec.Name),
 				CName: c.CIdentifier,
 				Doc:   c.Doc.StringSafe(),
-				Args:  c.Parameters.Template(ns.Name, "", p.Types, c.Throws),
+				Args:  c.Parameters.Template(ns.Name, "", p.Types, c.Throws, types.ArgsFromGoToC),
 				Ret:   c.ReturnValue.Template(ns.Name, "", p.Types, c.Throws),
 			}
 		}
 				fieldName = "x" + util.SnakeToCamel(f.Name) // Prefix callback pointer fields with `x` to make them private
 				callbackName := util.SnakeToCamel(f.Name)
-				args := f.Callback.Parameters.Template(ns.Name, "", p.Types, f.Callback.Throws)
+				args := f.Callback.Parameters.Template(ns.Name, "", p.Types, f.Callback.Throws, types.ArgsFromCToGo)
 				ret := f.Callback.ReturnValue.Template(ns.Name, "", p.Types, f.Callback.Throws)
 				apiTypes := args.API.Types
 				Doc:   f.Doc.StringSafe(),
 				Name:  name,
 				CName: f.CIdentifier,
-				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws),
+				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws, types.ArgsFromGoToC),
 				Ret:   f.ReturnValue.Template(ns.Name, "", p.Types, f.Throws),
 			})
 		}
 		cbT := types.CallbackTemplate{
 			Doc:  cb.Doc.StringSafe(),
 			Name: cb.Name,
-			Args: cb.Parameters.Template(ns.Name, "", p.Types, cb.Throws),
+			Args: cb.Parameters.Template(ns.Name, "", p.Types, cb.Throws, types.ArgsFromCToGo),
 			Ret:  cb.ReturnValue.Template(ns.Name, "", p.Types, cb.Throws),
 		}
 		callbacks[fn] = append(callbacks[fn], cbT)
 			Name:  name,
 			CName: f.CIdentifier,
 			Doc:   f.Doc.StringSafe(),
-			Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws),
+			Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws, types.ArgsFromGoToC),
 			Ret:   f.ReturnValue.Template(ns.Name, "", p.Types, f.Throws),
 		})
 	}
 				Name:  util.ConstructorName(c.Name, cls.Name),
 				CName: c.CIdentifier,
 				Doc:   c.Doc.StringSafe(),
-				Args:  c.Parameters.Template(ns.Name, "", p.Types, c.Throws),
+				Args:  c.Parameters.Template(ns.Name, "", p.Types, c.Throws, types.ArgsFromGoToC),
 				Ret:   c.ReturnValue.Template(ns.Name, "", p.Types, c.Throws),
 			}
 		}
 		signals := make([]types.SignalsTemplate, len(cls.Signals))
 		for i, s := range cls.Signals {
 			signals[i] = types.SignalsTemplate{
-				Doc:   s.Doc.StringSafe(),
+				Doc:      s.Doc.StringSafe(),
-				Name:  util.DashToCamel(s.Name),
+				Name:     util.DashToCamel(s.Name),
-				CName: s.Name,
+				CName:    s.Name,
-				Args:  s.Parameters.Template(ns.Name, "", p.Types, false),
+				Args:     s.Parameters.Template(ns.Name, "", p.Types, false, types.ArgsFromCToGo),
-				Ret:   s.ReturnValue.Template(ns.Name, "", p.Types, false),
+				Ret:      s.ReturnValue.Template(ns.Name, "", p.Types, false),
+				Detailed: s.Detailed,
 			}
 		}
 		receivers := make([]types.FuncTemplate, len(cls.Methods))
 				Doc:   f.Doc.StringSafe(),
 				Name:  name,
 				CName: f.CIdentifier,
-				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws),
+				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws, types.ArgsFromGoToC),
 				Ret:   f.ReturnValue.Template(ns.Name, "", p.Types, f.Throws),
 			}
 		}
 				Name:  name,
 				CName: f.CIdentifier,
 				Doc:   f.Doc.StringSafe(),
-				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws),
+				Args:  f.Parameters.Template(ns.Name, "", p.Types, f.Throws, types.ArgsFromGoToC),
 				Ret:   f.ReturnValue.Template(ns.Name, "", p.Types, f.Throws),
 			}
 		}
 		// as they should only be loaded when there are classes
 		needsInit := (len(functions[fn]) + methods) > 0
+		// Check if any receiver method has callback parameters
+		// This is used to conditionally import unsafe and purego
+		hasReceiverCallbacks := false
+		for _, rec := range records[fn] {
+			for _, r := range rec.Receivers {
+				if len(r.Args.Callbacks) > 0 {
+					hasReceiverCallbacks = true
+					break
+				}
+			}
+			if hasReceiverCallbacks {
+				break
+			}
+		}
+		if !hasReceiverCallbacks {
+			for _, cls := range classes[fn] {
+				for _, r := range cls.Receivers {
+					if len(r.Args.Callbacks) > 0 {
+						hasReceiverCallbacks = true
+						break
+					}
+				}
+				if hasReceiverCallbacks {
+					break
+				}
+			}
+		}
+		// Check if any standalone function has callback parameters
+		hasFunctionCallbacks := false
+		for _, f := range functions[fn] {
+			if len(f.Args.Callbacks) > 0 {
+				hasFunctionCallbacks = true
+				break
+			}
+		}
+		needsCoreHelpers := false
+		checkFuncArgs := func(funcs []types.FuncTemplate) {
+			if needsCoreHelpers {
+				return
+			}
+			for _, f := range funcs {
+				if f.Args.NeedsCore() {
+					needsCoreHelpers = true
+					return
+				}
+			}
+		}
+		checkInterfaceArgs := func(funcs []types.InterfaceFuncTemplate) {
+			if needsCoreHelpers {
+				return
+			}
+			for _, f := range funcs {
+				if f.Args.NeedsCore() {
+					needsCoreHelpers = true
+					return
+				}
+			}
+		}
+		for _, rec := range records[fn] {
+			checkFuncArgs(rec.Constructors)
+			checkFuncArgs(rec.Receivers)
+		}
+		for _, cls := range classes[fn] {
+			checkFuncArgs(cls.Constructors)
+			checkFuncArgs(cls.Receivers)
+			checkFuncArgs(cls.Functions)
+		}
+		checkFuncArgs(functions[fn])
+		for _, inter := range interfaces[fn] {
+			checkInterfaceArgs(inter.Methods)
+		}
 		args := types.TemplateArg{
-			PkgName:         pkgName,
+			PkgName:              pkgName,
-			PkgEnv:          strings.ToUpper(pkgName),
+			PkgEnv:               strings.ToUpper(pkgName),
-			PkgConfigName:   pkgConfigName,
+			PkgConfigName:        pkgConfigName,
-			SharedLibraries: sharedLibraries,
+			SharedLibraries:      sharedLibraries,
-			NeedsInit:       needsInit,
+			NeedsInit:            needsInit,
-			Aliases:         aliases[fn],
+			NeedsCore:            needsCoreHelpers,
-			Callbacks:       callbacks[fn],
+			HasReceiverCallbacks: hasReceiverCallbacks,
-			Records:         records[fn],
+			HasFunctionCallbacks: hasFunctionCallbacks,
-			Enums:           enums[fn],
+			Aliases:              aliases[fn],
-			Constants:       constants[fn],
+			Callbacks:            callbacks[fn],
-			Functions:       functions[fn],
+			Records:              records[fn],
-			Interfaces:      interfaces[fn],
+			Enums:                enums[fn],
-			Classes:         classes[fn],
+			Constants:            constants[fn],
+			Functions:            functions[fn],
+			Interfaces:           interfaces[fn],
+			Classes:              classes[fn],
 		}
 		os.MkdirAll(fmt.Sprintf(dir+"/%s", pkgName), 0o755)

M internal/gir/types/interface.go +1 -1


@@ -28,7 +28,7 @@ func ConvertInterface(currns string, ins string, inter Interface, implemented ma
28		Doc: m.Doc.StringSafe(),	28		Doc: m.Doc.StringSafe(),
29		CName: m.CIdentifier,	29		CName: m.CIdentifier,
30		Name: name,	30		Name: name,
31	-	Args: m.Parameters.Template(currns, ins, kinds, m.Throws),	31	+	Args: m.Parameters.Template(currns, ins, kinds, m.Throws, ArgsFromGoToC),
32		Ret: m.ReturnValue.Template(currns, ins, kinds, m.Throws),	32		Ret: m.ReturnValue.Template(currns, ins, kinds, m.Throws),
33		},	33		},
34		})	34		})

M internal/gir/types/kind.go +11 -0


@@ -53,6 +53,17 @@ func (km KindMap) MustInterface(ns string, name string) Interface {
53	return p.Value.(Interface)	53		return p.Value.(Interface)
54	}	54		}
55		55
		56	+	// GetCallback retrieves a callback definition by namespace and name.
		57	+	// Returns the Callback and true if found, otherwise nil and false.
		58	+	func (km KindMap) GetCallback(ns string, name string) (Callback, bool) {
		59	+	p := km.pair(ns, name)
		60	+	if p.K != CallbackType {
		61	+	return Callback{}, false
		62	+	}
		63	+	cb, ok := p.Value.(Callback)
		64	+	return cb, ok
		65	+	}
		66	+
56	type KindPair struct {	67		type KindPair struct {
57	K Kind	68		K Kind
58	Value interface{}	69		Value interface{}

M internal/gir/types/template.go +188 -11


@@ -17,9 +17,27 @@ type argsTemplate struct {
17		// Call are the variables as given in a function call	17		// Call are the variables as given in a function call
18		Call []string	18		Call []string
19			19
			20	+	// CallWithRefs is like Call but with callback parameters using {name}Ref
			21	+	// for use in contexts that generate closure wrappers
			22	+	CallWithRefs []string
			23	+
20		Full []string	24		Full []string
21		}	25		}
22			26
			27	+	// CallbackParam holds metadata for callback parameters to enable proper closure generation
			28	+	type CallbackParam struct {
			29	+	// Name is the parameter name (e.g., "CallbackVar")
			30	+	Name string
			31	+	// TypeName is the callback type name (e.g., "TickCallback")
			32	+	TypeName string
			33	+	// PureTypes are the pure argument types for the closure
			34	+	PureTypes []string
			35	+	// RetRaw is the return type for the closure (e.g., "bool")
			36	+	RetRaw string
			37	+	// Nullable indicates if the callback can be nil
			38	+	Nullable bool
			39	+	}
			40	+
23		type funcArgsTemplate struct {	41		type funcArgsTemplate struct {
24		// Pure are the arguments as passed directly to PureGo	42		// Pure are the arguments as passed directly to PureGo
25		// The pure Call is a special case that contains the arguments for a callback call	43		// The pure Call is a special case that contains the arguments for a callback call

@@ -27,16 +45,99 @@ type funcArgsTemplate struct {
27			45
28		// API are the arguments as suitable for a Go API	46		// API are the arguments as suitable for a Go API
29		API argsTemplate	47		API argsTemplate
			48	+
			49	+	// Callbacks tracks callback parameters for proper closure generation
			50	+	Callbacks []CallbackParam
			51	+
			52	+	// UsesNullableHelper indicates nullable string handling that needs core import.
			53	+	UsesNullableHelper bool
30		}	54		}
31			55
32	-	func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullable bool, isOut bool) {	56	+	// ArgContext indicates where the arguments are flowing so we can handle
			57	+	// direction-sensitive cases (e.g. nullable strings) differently.
			58	+	type ArgContext int
			59	+
			60	+	const (
			61	+	// ArgsFromGoToC covers regular functions/methods where Go calls into C.
			62	+	ArgsFromGoToC ArgContext = iota
			63	+	// ArgsFromCToGo covers callbacks/signals where C calls into Go.
			64	+	ArgsFromCToGo
			65	+	)
			66	+
			67	+	func isStringType(t string) bool {
			68	+	if strings.HasPrefix(t, "[]") {
			69	+	return false
			70	+	}
			71	+	return strings.TrimLeft(t, "*") == "string"
			72	+	}
			73	+
			74	+	// NeedsCore reports whether this argument set requires core helpers.
			75	+	func (f funcArgsTemplate) NeedsCore() bool {
			76	+	return f.UsesNullableHelper
			77	+	}
			78	+
			79	+	func qualifyCallbackType(t string, callbackNS string, currentNS string) string {
			80	+	if t == "" \|\| callbackNS == "" \|\| strings.EqualFold(callbackNS, currentNS) {
			81	+	return t
			82	+	}
			83	+
			84	+	if strings.Contains(t, ".") {
			85	+	return t
			86	+	}
			87	+
			88	+	ptrPrefix := ""
			89	+	base := t
			90	+	for strings.HasPrefix(base, "*") {
			91	+	ptrPrefix += "*"
			92	+	base = strings.TrimPrefix(base, "*")
			93	+	}
			94	+
			95	+	slicePrefix := ""
			96	+	for strings.HasPrefix(base, "[]") {
			97	+	slicePrefix += "[]"
			98	+	base = strings.TrimPrefix(base, "[]")
			99	+	}
			100	+
			101	+	arrayPrefix := ""
			102	+	for strings.HasPrefix(base, "[") {
			103	+	end := strings.Index(base, "]")
			104	+	if end == -1 {
			105	+	break
			106	+	}
			107	+	arrayPrefix += base[:end+1]
			108	+	base = base[end+1:]
			109	+	}
			110	+
			111	+	switch base {
			112	+	case "bool", "byte", "complex64", "complex128", "error", "float32", "float64", "int", "int8", "int16", "int32", "int64", "rune", "string", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr":
			113	+	return t
			114	+	}
			115	+
			116	+	if base == "" {
			117	+	return t
			118	+	}
			119	+
			120	+	qualifiedBase := callbackNS + "." + base
			121	+	return ptrPrefix + slicePrefix + arrayPrefix + qualifiedBase
			122	+	}
			123	+
			124	+	func qualifyCallbackTypes(types []string, callbackNS string, currentNS string) []string {
			125	+	qualified := make([]string, len(types))
			126	+	for i, t := range types {
			127	+	qualified[i] = qualifyCallbackType(t, callbackNS, currentNS)
			128	+	}
			129	+	return qualified
			130	+	}
			131	+
			132	+	func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullable bool, isOut bool, ctx ArgContext) {
33		c := n	133		c := n
			134	+	cRef := n // For CallWithRefs, defaults to same as Call
34		stars := strings.Count(t, "*")	135		stars := strings.Count(t, "*")
35		gobjectNs := "gobject."	136		gobjectNs := "gobject."
			137	+	glibNs := "glib."
36		if strings.ToLower(ns) == "gobject" {	138		if strings.ToLower(ns) == "gobject" {
37		gobjectNs = ""	139		gobjectNs = ""
38		}	140		}
39	-	glibNs := "glib."
40		if strings.ToLower(ns) == "glib" {	141		if strings.ToLower(ns) == "glib" {
41		glibNs = ""	142		glibNs = ""
42		}	143		}

@@ -48,14 +149,28 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
48		t = "*" + t	149		t = "*" + t
49		}	150		}
50		c = n	151		c = n
			152	+	cRef = n
51		} else {	153		} else {
			154	+	// Nullable strings differ based on direction. For Go->C we need a *string API type
			155	+	// and pass a pointer (or nil) to C. For C->Go we keep the string as-is.
			156	+	if ctx == ArgsFromGoToC && nullable && isStringType(t) {
			157	+	f.UsesNullableHelper = true
			158	+	t = "*string"
			159	+	c = fmt.Sprintf("core.NullableStringToPtr(%s)", n)
			160	+	cRef = c
			161	+	}
			162	+
52		switch k {	163		switch k {
53		case CallbackType:	164		case CallbackType:
			165	+	// Call uses glib.NewCallback for contexts like callback accessor getters
54		if nullable {	166		if nullable {
55		c = fmt.Sprintf("%sNewCallbackNullable(%s)", glibNs, n)	167		c = fmt.Sprintf("%sNewCallbackNullable(%s)", glibNs, n)
56		} else {	168		} else {
57		c = fmt.Sprintf("%sNewCallback(%s)", glibNs, n)	169		c = fmt.Sprintf("%sNewCallback(%s)", glibNs, n)
58		}	170		}
			171	+	// For CallWithRefs, start with the same value as Call
			172	+	// It will be updated to {name}Ref in Add() if the callback lookup succeeds
			173	+	cRef = c
59		t = "*" + t	174		t = "*" + t
60		case ClassesType:	175		case ClassesType:
61		if stars == 0 {	176		if stars == 0 {

@@ -66,6 +181,7 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
66		} else if stars == 1 {	181		} else if stars == 1 {
67		c = n + ".GoPointer()"	182		c = n + ".GoPointer()"
68		}	183		}
			184	+	cRef = c
69		case InterfacesType:	185		case InterfacesType:
70		t = strings.TrimPrefix(t, "*")	186		t = strings.TrimPrefix(t, "*")
71		if stars == 0 {	187		if stars == 0 {

@@ -76,21 +192,26 @@ func (f *funcArgsTemplate) AddAPI(t string, n string, k Kind, ns string, nullabl
76		} else if stars == 1 {	192		} else if stars == 1 {
77		c = n + ".GoPointer()"	193		c = n + ".GoPointer()"
78		}	194		}
			195	+	cRef = c
			196	+	default:
			197	+	cRef = c
79		}	198		}
80			199
81		// special case for varargs	200		// special case for varargs
82		if n == "varArgs" {	201		if n == "varArgs" {
83		c = n + "..."	202		c = n + "..."
			203	+	cRef = c
84		}	204		}
85		}	205		}
86			206
87		f.API.Names = append(f.API.Names, n)	207		f.API.Names = append(f.API.Names, n)
88		f.API.Types = append(f.API.Types, t)	208		f.API.Types = append(f.API.Types, t)
89		f.API.Call = append(f.API.Call, c)	209		f.API.Call = append(f.API.Call, c)
			210	+	f.API.CallWithRefs = append(f.API.CallWithRefs, cRef)
90		f.API.Full = append(f.API.Full, n+" "+t)	211		f.API.Full = append(f.API.Full, n+" "+t)
91		}	212		}
92			213
93	-	func (f *funcArgsTemplate) AddPure(t string, n string, k Kind, isOut bool) {	214	+	func (f *funcArgsTemplate) AddPure(t string, n string, k Kind, isOut bool, nullable bool, ctx ArgContext) {
94		n += "p"	215		n += "p"
95		c := n	216		c := n
96		stars := strings.Count(t, "*")	217		stars := strings.Count(t, "*")

@@ -103,6 +224,12 @@ func (f *funcArgsTemplate) AddPure(t string, n string, k Kind, isOut bool) {
103		}	224		}
104		c = n	225		c = n
105		} else {	226		} else {
			227	+	if ctx == ArgsFromGoToC && nullable && isStringType(t) {
			228	+	f.UsesNullableHelper = true
			229	+	t = "uintptr"
			230	+	c = fmt.Sprintf("core.NullableStringToPtr(%s)", strings.TrimSuffix(n, "p"))
			231	+	}
			232	+
106		switch k {	233		switch k {
107		case RecordsType:	234		case RecordsType:
108		if stars == 0 {	235		if stars == 0 {

@@ -142,7 +269,7 @@ func (f *funcArgsTemplate) AddPure(t string, n string, k Kind, isOut bool) {
142		f.Pure.Full = append(f.Pure.Full, n+" "+t)	269		f.Pure.Full = append(f.Pure.Full, n+" "+t)
143		}	270		}
144			271
145	-	func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap) {	272	+	func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap, ctx ArgContext) {
146		// get the lookup namespace	273		// get the lookup namespace
147		// as if the interface namespace is non-empty	274		// as if the interface namespace is non-empty
148		// means we can also lookup in the namespace of the interface	275		// means we can also lookup in the namespace of the interface

@@ -153,6 +280,9 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
153		goType := p.Translate(lns, kinds)	280		goType := p.Translate(lns, kinds)
154		kind := kinds.Kind(lns, goType)	281		kind := kinds.Kind(lns, goType)
155			282
			283	+	// Save the original type name before normalization for callback lookup
			284	+	originalType := goType
			285	+
156		stars := strings.Count(goType, "*")	286		stars := strings.Count(goType, "*")
157		goType = util.NormalizeNamespace(ns, goType, true)	287		goType = util.NormalizeNamespace(ns, goType, true)
158			288

@@ -168,12 +298,51 @@ func (f *funcArgsTemplate) Add(p Parameter, ins string, ns string, kinds KindMap
168			298
169		isOut := p.Direction == "out"	299		isOut := p.Direction == "out"
170			300
171	-	f.AddAPI(goType, varName, kind, ns, p.Nullable, isOut)	301	+	f.AddAPI(goType, varName, kind, ns, p.Nullable, isOut, ctx)
172	-	f.AddPure(goType, varName, kind, isOut)	302	+	f.AddPure(goType, varName, kind, isOut, p.Nullable, ctx)
			303	+
			304	+	// For callback parameters (not out parameters), populate callback metadata
			305	+	// This enables the template to generate proper closure wrapping
			306	+	if kind == CallbackType && !isOut {
			307	+	if cb, ok := kinds.GetCallback(lns, originalType); ok {
			308	+	// Determine the callback's namespace from the original type name
			309	+	// e.g., "gio.AsyncReadyCallback" -> "gio", "AsyncReadyCallback" -> lns
			310	+	cbNs := lns
			311	+	if parts := strings.Split(originalType, "."); len(parts) > 1 {
			312	+	cbNs = parts[0]
			313	+	}
			314	+
			315	+	// Get the callback's pure argument types and return type
			316	+	// Use cbNs (callback's namespace) for proper type lookups
			317	+	cbArgs := cb.Parameters.Template(cbNs, "", kinds, cb.Throws, ArgsFromCToGo)
			318	+	var retRaw string
			319	+	if cb.ReturnValue != nil {
			320	+	cbRet := cb.ReturnValue.Template(cbNs, "", kinds, cb.Throws)
			321	+	retRaw = cbRet.Raw
			322	+	}
			323	+
			324	+	qualifiedPureTypes := qualifyCallbackTypes(cbArgs.Pure.Types, cbNs, ns)
			325	+	qualifiedRetRaw := qualifyCallbackType(retRaw, cbNs, ns)
			326	+
			327	+	f.Callbacks = append(f.Callbacks, CallbackParam{
			328	+	Name: varName,
			329	+	TypeName: strings.TrimPrefix(goType, "*"),
			330	+	PureTypes: qualifiedPureTypes,
			331	+	RetRaw: qualifiedRetRaw,
			332	+	Nullable: p.Nullable,
			333	+	})
			334	+
			335	+	// Update CallWithRefs to use {name}Ref since we have the callback info
			336	+	// for generating the closure wrapper
			337	+	lastIdx := len(f.API.CallWithRefs) - 1
			338	+	f.API.CallWithRefs[lastIdx] = varName + "Ref"
			339	+	}
			340	+	}
173		}	341		}
174			342
175		func (f *funcArgsTemplate) AddThrows(ns string) {	343		func (f *funcArgsTemplate) AddThrows(ns string) {
176		f.API.Call = append(f.API.Call, "&cerr")	344		f.API.Call = append(f.API.Call, "&cerr")
			345	+	f.API.CallWithRefs = append(f.API.CallWithRefs, "&cerr")
177		if strings.ToLower(ns) != "glib" {	346		if strings.ToLower(ns) != "glib" {
178		f.Pure.Types = append(f.Pure.Types, "**glib.Error")	347		f.Pure.Types = append(f.Pure.Types, "**glib.Error")
179		} else {	348		} else {

@@ -410,11 +579,12 @@ type InterfaceFuncTemplate struct {
410		}	579		}
411			580
412		type SignalsTemplate struct {	581		type SignalsTemplate struct {
413	-	Doc string	582	+	Doc string
414	-	Name string	583	+	Name string
415	-	CName string	584	+	CName string
416	-	Args funcArgsTemplate	585	+	Args funcArgsTemplate
417	-	Ret funcRetTemplate	586	+	Ret funcRetTemplate
			587	+	Detailed bool
418		}	588		}
419			589
420		type PropertyTemplate struct {	590		type PropertyTemplate struct {

@@ -483,6 +653,13 @@ type TemplateArg struct {
483		SharedLibraries []string	653		SharedLibraries []string
484		// NeedsInit declares whether or not this file needs an init code to register functions with purego	654		// NeedsInit declares whether or not this file needs an init code to register functions with purego
485		NeedsInit bool	655		NeedsInit bool
			656	+	// NeedsCore indicates if core helpers are required even without init.
			657	+	NeedsCore bool
			658	+	// HasReceiverCallbacks indicates if any receiver method has callback parameters
			659	+	// This is used to conditionally import unsafe and purego
			660	+	HasReceiverCallbacks bool
			661	+	// HasFunctionCallbacks indicates if any standalone function has callback parameters
			662	+	HasFunctionCallbacks bool
486		// Imports defines the package imports that we need	663		// Imports defines the package imports that we need
487		// This does not include purego	664		// This does not include purego
488		// As the template already includes that if `NeedsInit` is set to true	665		// As the template already includes that if `NeedsInit` is set to true

M internal/gir/types/types.go +2 -2


@@ -658,7 +658,7 @@ func (p *Parameter) VarName() string {
658		return snaked + "Var"	658		return snaked + "Var"
659		}	659		}
660			660
661	-	func (p *Parameters) Template(ns string, ifacens string, kinds KindMap, throws bool) funcArgsTemplate {	661	+	func (p *Parameters) Template(ns string, ifacens string, kinds KindMap, throws bool, ctx ArgContext) funcArgsTemplate {
662		if p == nil {	662		if p == nil {
663		return funcArgsTemplate{}	663		return funcArgsTemplate{}
664		}	664		}

@@ -668,7 +668,7 @@ func (p *Parameters) Template(ns string, ifacens string, kinds KindMap, throws b
668		}	668		}
669		args := funcArgsTemplate{}	669		args := funcArgsTemplate{}
670		for _, par := range params {	670		for _, par := range params {
671	-	args.Add(par, ifacens, ns, kinds)	671	+	args.Add(par, ifacens, ns, kinds, ctx)
672		}	672		}
673		if throws {	673		if throws {
674		args.AddThrows(ns)	674		args.AddThrows(ns)

M internal/gir/util/util.go +35 -0


@@ -93,15 +93,47 @@ func AddNamespace(val, ns string) string {
93	if ns == "" \|\| strings.Count(val, ".") >= 1 {	93		if ns == "" \|\| strings.Count(val, ".") >= 1 {
94	return val	94		return val
95	}	95		}
		96	+	// Don't add namespace to Go builtin types
		97	+	if isGoBuiltinType(val) {
		98	+	return val
		99	+	}
96	return PrefixValue(val, ns+".")	100		return PrefixValue(val, ns+".")
97	}	101		}
98		102
		103	+	// goBuiltinTypes contains Go builtin types that should never be namespace-prefixed
		104	+	var goBuiltinTypes = map[string]bool{
		105	+	"bool": true, "byte": true, "complex64": true, "complex128": true,
		106	+	"error": true, "float32": true, "float64": true, "int": true,
		107	+	"int8": true, "int16": true, "int32": true, "int64": true,
		108	+	"rune": true, "string": true, "uint": true, "uint8": true,
		109	+	"uint16": true, "uint32": true, "uint64": true, "uintptr": true,
		110	+	}
		111	+
		112	+	// isGoBuiltinType checks if the given type (after stripping pointers and slices) is a Go builtin
		113	+	func isGoBuiltinType(gotype string) bool {
		114	+	// Strip pointer prefixes
		115	+	baseType := strings.TrimLeft(gotype, "*")
		116	+	// Strip slice prefix
		117	+	baseType = strings.TrimPrefix(baseType, "[]")
		118	+	// Strip any remaining pointers (e.g., *[]byte -> []byte -> byte)
		119	+	baseType = strings.TrimLeft(baseType, "*")
		120	+	return goBuiltinTypes[baseType]
		121	+	}
		122	+
99	// NormalizeNamespace converts a type to one that always includes a lowercase namespace	123		// NormalizeNamespace converts a type to one that always includes a lowercase namespace
100	// if no namespace is found, it adds `ns`, unless if strip is True then namespaces always equaling `ns` will be removed	124		// if no namespace is found, it adds `ns`, unless if strip is True then namespaces always equaling `ns` will be removed
101	func NormalizeNamespace(ns string, gotype string, strip bool) string {	125		func NormalizeNamespace(ns string, gotype string, strip bool) string {
102	if ns == "" {	126		if ns == "" {
103	return ""	127		return ""
104	}	128		}
		129	+
		130	+	// Check if this is a Go builtin type before any modifications
		131	+	// Note: gotype here may still have * prefixes which are trimmed below
		132	+	trimmedForCheck := strings.Trim(gotype, "*")
		133	+	if isGoBuiltinType(trimmedForCheck) {
		134	+	return trimmedForCheck
		135	+	}
		136	+
105	gotype = strings.Trim(gotype, "*")	137		gotype = strings.Trim(gotype, "*")
106	splt := strings.Split(gotype, ".")	138		splt := strings.Split(gotype, ".")
107	if len(splt) <= 1 {	139		if len(splt) <= 1 {

@@ -220,6 +252,9 @@ func PropertyScalarSet(notGObject bool, gvalueType, setMethod string) string {
220	if notGObject {	252		if notGObject {
221	prefix = "gobject."	253		prefix = "gobject."
222	}	254		}
		255	+	if setMethod == "SetString" {
		256	+	return prefix + gvalueType + ")\n\tv." + setMethod + "(&value"
		257	+	}
223	return prefix + gvalueType + ")\n\tv." + setMethod + "(value"	258		return prefix + gvalueType + ")\n\tv." + setMethod + "(value"
224	}	259		}
225		260

M pkg/core/core.go +9 -7


@@ -3,11 +3,13 @@ package core
3		import "github.com/jwijenbergh/puregotk/internal/core"	3		import "github.com/jwijenbergh/puregotk/internal/core"
4			4
5		var (	5		var (
6	-	GetPaths = core.GetPaths	6	+	GetPaths = core.GetPaths
7	-	ByteSlice = core.ByteSlice	7	+	ByteSlice = core.ByteSlice
8	-	GoStringSlice = core.GoStringSlice	8	+	GoStringSlice = core.GoStringSlice
9	-	GoString = core.GoString	9	+	GoString = core.GoString
10	-	SetPackageName = core.SetPackageName	10	+	NullableStringToPtr = core.NullableStringToPtr
11	-	SetSharedLibraries = core.SetSharedLibraries	11	+	PtrToNullableString = core.PtrToNullableString
12	-	PuregoSafeRegister = core.PuregoSafeRegister	12	+	SetPackageName = core.SetPackageName
			13	+	SetSharedLibraries = core.SetSharedLibraries
			14	+	PuregoSafeRegister = core.PuregoSafeRegister
13		)	15		)

M templates/go +151 -10


@@ -4,27 +4,38 @@ package {{.PkgName}}
4		{{ $NotGObject := ne .PkgName "gobject" }}	4		{{ $NotGObject := ne .PkgName "gobject" }}
5		{{ $NotGLib := ne .PkgName "glib" }}	5		{{ $NotGLib := ne .PkgName "glib" }}
6		{{ $HasSignals := false }}	6		{{ $HasSignals := false }}
			7	+	{{ $HasDetailedSignals := false }}
7		{{range .Classes -}}	8		{{range .Classes -}}
8		{{if .Signals}}	9		{{if .Signals}}
9		{{ $HasSignals = true }}	10		{{ $HasSignals = true }}
10		{{end}}	11		{{end}}
			12	+	{{range .Signals}}
			13	+	{{if .Detailed}}
			14	+	{{ $HasDetailedSignals = true }}
			15	+	{{end}}
			16	+	{{end}}
11		{{end}}	17		{{end}}
12	-	{{ $NeedsUnsafe := or .Records $HasSignals }}	18	+	{{ $HasCallbacks := or .HasReceiverCallbacks .HasFunctionCallbacks }}
13	-	{{ $NeedsPurego := or .NeedsInit $HasSignals }}	19	+	{{ $NeedsUnsafe := or .Records $HasSignals $HasCallbacks }}
14	-	{{ $AnyImports := or .NeedsInit .Records $HasSignals }}	20	+	{{ $NeedsPurego := or .NeedsInit $HasSignals $HasCallbacks }}
			21	+	{{ $NeedsCore := or .NeedsInit .NeedsCore }}
			22	+	{{ $AnyImports := or $NeedsCore .Records $HasSignals $HasCallbacks $HasDetailedSignals }}
15			23
16		{{if $AnyImports}}	24		{{if $AnyImports}}
17		import (	25		import (
18		{{- if $NeedsUnsafe}}	26		{{- if $NeedsUnsafe}}
19		"unsafe"	27		"unsafe"
20		{{- end}}	28		{{- end}}
			29	+	{{- if $HasDetailedSignals}}
			30	+	"fmt"
			31	+	{{- end}}
21		{{- if .Records}}	32		{{- if .Records}}
22		"structs"	33		"structs"
23		{{- end}}	34		{{- end}}
24		{{- if $NeedsPurego}}	35		{{- if $NeedsPurego}}
25		"github.com/jwijenbergh/purego"	36		"github.com/jwijenbergh/purego"
26		{{- end}}	37		{{- end}}
27	-	{{- if .NeedsInit}}	38	+	{{- if $NeedsCore}}
28		"github.com/jwijenbergh/puregotk/pkg/core"	39		"github.com/jwijenbergh/puregotk/pkg/core"
29		{{- end}}	40		{{- end}}
30		)	41		)

@@ -66,7 +77,24 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
66		{{.Doc}}	77		{{.Doc}}
67		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	78		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
68		{{.Ret.Preamble $NotGLib}}	79		{{.Ret.Preamble $NotGLib}}
69	-	{{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.Call}})	80	+	{{- /* Generate closure wrappers for callback parameters */}}
			81	+	{{range .Args.Callbacks}}
			82	+	var {{.Name}}Ref uintptr
			83	+	if {{.Name}} != nil {
			84	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			85	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			86	+	{{.Name}}Ref = cbRefPtr
			87	+	} else {
			88	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			89	+	cbFn := *{{.Name}}
			90	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			91	+	}
			92	+	{{.Name}}Ref = purego.NewCallback(fcb)
			93	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			94	+	}
			95	+	}
			96	+	{{end}}
			97	+	{{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
70		{{.Ret.Fmt $NotGObject}}	98		{{.Ret.Fmt $NotGObject}}
71		}	99		}
72		{{end}}	100		{{end}}

@@ -78,7 +106,24 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
78		{{.Doc}}	106		{{.Doc}}
79		func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	107		func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
80		{{.Ret.Preamble $NotGLib}}	108		{{.Ret.Preamble $NotGLib}}
81	-	{{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.Call}})	109	+	{{- /* Generate closure wrappers for callback parameters */}}
			110	+	{{range .Args.Callbacks}}
			111	+	var {{.Name}}Ref uintptr
			112	+	if {{.Name}} != nil {
			113	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			114	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			115	+	{{.Name}}Ref = cbRefPtr
			116	+	} else {
			117	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			118	+	cbFn := *{{.Name}}
			119	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			120	+	}
			121	+	{{.Name}}Ref = purego.NewCallback(fcb)
			122	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			123	+	}
			124	+	}
			125	+	{{end}}
			126	+	{{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
82		{{.Ret.Fmt $NotGObject}}	127		{{.Ret.Fmt $NotGObject}}
83		}	128		}
84		{{end}}	129		{{end}}

@@ -239,7 +284,24 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
239		{{.Doc}}	284		{{.Doc}}
240		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	285		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
241		{{.Ret.Preamble $NotGLib}}	286		{{.Ret.Preamble $NotGLib}}
242	-	{{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.Call}})	287	+	{{- /* Generate closure wrappers for callback parameters */}}
			288	+	{{range .Args.Callbacks}}
			289	+	var {{.Name}}Ref uintptr
			290	+	if {{.Name}} != nil {
			291	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			292	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			293	+	{{.Name}}Ref = cbRefPtr
			294	+	} else {
			295	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			296	+	cbFn := *{{.Name}}
			297	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			298	+	}
			299	+	{{.Name}}Ref = purego.NewCallback(fcb)
			300	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			301	+	}
			302	+	}
			303	+	{{end}}
			304	+	{{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
243		{{.Ret.Fmt $NotGObject}}	305		{{.Ret.Fmt $NotGObject}}
244		}	306		}
245		{{end}}	307		{{end}}

@@ -274,7 +336,24 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
274		{{.Doc}}	336		{{.Doc}}
275		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	337		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
276		{{.Ret.Preamble $NotGLib}}	338		{{.Ret.Preamble $NotGLib}}
277	-	{{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.Call}})	339	+	{{- /* Generate closure wrappers for callback parameters */}}
			340	+	{{range .Args.Callbacks}}
			341	+	var {{.Name}}Ref uintptr
			342	+	if {{.Name}} != nil {
			343	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			344	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			345	+	{{.Name}}Ref = cbRefPtr
			346	+	} else {
			347	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			348	+	cbFn := *{{.Name}}
			349	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			350	+	}
			351	+	{{.Name}}Ref = purego.NewCallback(fcb)
			352	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			353	+	}
			354	+	}
			355	+	{{end}}
			356	+	{{if .Ret.Value}}cret :={{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
278		{{.Ret.Fmt $NotGObject}}	357		{{.Ret.Fmt $NotGObject}}
279		}	358		}
280		{{end}}	359		{{end}}

@@ -286,7 +365,24 @@ var x{{$outer.Name}}{{.Name}} func(uintptr {{convc .Args.Pure.Types}}) {{.Ret.Ra
286		{{.Doc}}	365		{{.Doc}}
287		func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	366		func (x *{{$outer.Name}}) {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
288		{{.Ret.Preamble $NotGLib}}	367		{{.Ret.Preamble $NotGLib}}
289	-	{{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.Call}})	368	+	{{- /* Generate closure wrappers for callback parameters */}}
			369	+	{{range .Args.Callbacks}}
			370	+	var {{.Name}}Ref uintptr
			371	+	if {{.Name}} != nil {
			372	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			373	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			374	+	{{.Name}}Ref = cbRefPtr
			375	+	} else {
			376	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			377	+	cbFn := *{{.Name}}
			378	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			379	+	}
			380	+	{{.Name}}Ref = purego.NewCallback(fcb)
			381	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			382	+	}
			383	+	}
			384	+	{{end}}
			385	+	{{if .Ret.Value}}cret :={{end}}x{{$outer.Name}}{{.Name}}(x.GoPointer() {{convcd .Args.API.CallWithRefs}})
290		{{.Ret.Fmt $NotGObject}}	386		{{.Ret.Fmt $NotGObject}}
291		}	387		}
292		{{end}}	388		{{end}}

@@ -350,6 +446,34 @@ func (x {{$outer.Name}}) Connect{{.Name}}(cb func({{$outer.Name}} {{convc .Arg
350		{{if $NotGLib}}glib.{{end}}SaveCallback(cbPtr, cbRefPtr)	446		{{if $NotGLib}}glib.{{end}}SaveCallback(cbPtr, cbRefPtr)
351		return {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), "{{.CName}}", cbRefPtr)	447		return {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), "{{.CName}}", cbRefPtr)
352		}	448		}
			449	+	{{if .Detailed}}
			450	+	// Connect{{.Name}}WithDetail connects to the "{{.CName}}" signal with a detail string.
			451	+	// The detail is appended as "{{.CName}}::<detail>".
			452	+	func (x {{$outer.Name}}) Connect{{.Name}}WithDetail(detail string, cb func({{$outer.Name}} {{convc .Args.API.Types}}) {{.Ret.Value}}) uint32 {
			453	+	cbPtr := uintptr(unsafe.Pointer(cb))
			454	+	signalName := fmt.Sprintf("{{.CName}}::%s", detail)
			455	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback(cbPtr); ok {
			456	+	return {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			457	+	}
			458	+
			459	+	fcb := func(clsPtr uintptr {{convc .Args.Pure.Full}}) {{.Ret.Raw}} {
			460	+	fa := {{$outer.Name}}{}
			461	+	fa.Ptr = clsPtr
			462	+	cbFn := *cb
			463	+	{{if .Ret.Class}}
			464	+	{{.Name}}Cls := cbFn(fa {{convc .Args.Pure.Call}})
			465	+	return {{.Name}}Cls.Ptr
			466	+	{{else if .Ret.Value}}
			467	+	return cbFn(fa {{convc .Args.Pure.Call}})
			468	+	{{else}}
			469	+	cbFn(fa {{convc .Args.Pure.Call}})
			470	+	{{end}}
			471	+	}
			472	+	cbRefPtr := purego.NewCallback(fcb)
			473	+	{{if $NotGLib}}glib.{{end}}SaveCallback(cbPtr, cbRefPtr)
			474	+	return {{if $NotGObject}}gobject.{{end}}SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			475	+	}
			476	+	{{end}}
353		{{end}}	477		{{end}}
354			478
355		{{range .Interfaces -}}	479		{{range .Interfaces -}}

@@ -369,7 +493,24 @@ var x{{.Name}} func({{conv .Args.Pure.Types}}) {{.Ret.Raw}}
369		{{.Doc}}	493		{{.Doc}}
370		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {	494		func {{.Name}}({{conv .Args.API.Full}}) {{.Ret.Return}} {
371		{{.Ret.Preamble $NotGLib}}	495		{{.Ret.Preamble $NotGLib}}
372	-	{{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.Call}})	496	+	{{- /* Generate closure wrappers for callback parameters */}}
			497	+	{{range .Args.Callbacks}}
			498	+	var {{.Name}}Ref uintptr
			499	+	if {{.Name}} != nil {
			500	+	{{.Name}}Ptr := uintptr(unsafe.Pointer({{.Name}}))
			501	+	if cbRefPtr, ok := {{if $NotGLib}}glib.{{end}}GetCallback({{.Name}}Ptr); ok {
			502	+	{{.Name}}Ref = cbRefPtr
			503	+	} else {
			504	+	fcb := func({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}} {{$t}}{{end}}) {{.RetRaw}} {
			505	+	cbFn := *{{.Name}}
			506	+	{{if .RetRaw}}return {{end}}cbFn({{range $i, $t := .PureTypes}}{{if $i}}, {{end}}arg{{$i}}{{end}})
			507	+	}
			508	+	{{.Name}}Ref = purego.NewCallback(fcb)
			509	+	{{if $NotGLib}}glib.{{end}}SaveCallback({{.Name}}Ptr, {{.Name}}Ref)
			510	+	}
			511	+	}
			512	+	{{end}}
			513	+	{{if .Ret.Value}}cret := {{end}}x{{.Name}}({{convd .Args.API.CallWithRefs}})
373		{{.Ret.Fmt $NotGObject}}	514		{{.Ret.Fmt $NotGObject}}
374		}	515		}
375		{{end}}	516		{{end}}

M v4/adw/adw-about-dialog.go +30 -30


@@ -32,15 +32,15 @@ func ShowAboutDialog(ParentVar *gtk.Widget, FirstPropertyNameVar string, varArgs
32			32
33		}	33		}
34			34
35	-	var xShowAboutDialogFromAppdata func(uintptr, string, string, string, ...interface{})	35	+	var xShowAboutDialogFromAppdata func(uintptr, string, uintptr, string, ...interface{})
36			36
37		// A convenience function for showing an application’s about dialog from	37		// A convenience function for showing an application’s about dialog from
38		// AppStream metadata.	38		// AppStream metadata.
39		//	39		//
40		// See [ctor@AboutDialog.new_from_appdata] for details.	40		// See [ctor@AboutDialog.new_from_appdata] for details.
41	-	func ShowAboutDialogFromAppdata(ParentVar *gtk.Widget, ResourcePathVar string, ReleaseNotesVersionVar string, FirstPropertyNameVar string, varArgs ...interface{}) {	41	+	func ShowAboutDialogFromAppdata(ParentVar gtk.Widget, ResourcePathVar string, ReleaseNotesVersionVar string, FirstPropertyNameVar string, varArgs ...interface{}) {
42			42
43	-	xShowAboutDialogFromAppdata(ParentVar.GoPointer(), ResourcePathVar, ReleaseNotesVersionVar, FirstPropertyNameVar, varArgs...)	43	+	xShowAboutDialogFromAppdata(ParentVar.GoPointer(), ResourcePathVar, core.NullableStringToPtr(ReleaseNotesVersionVar), FirstPropertyNameVar, varArgs...)
44			44
45		}	45		}
46			46

@@ -253,7 +253,7 @@ func NewAboutDialog() *AboutDialog {
253		return cls	253		return cls
254		}	254		}
255			255
256	-	var xNewAboutDialogFromAppdata func(string, string) uintptr	256	+	var xNewAboutDialogFromAppdata func(string, uintptr) uintptr
257			257
258		// Creates a new `AdwAboutDialog` using AppStream metadata.	258		// Creates a new `AdwAboutDialog` using AppStream metadata.
259		//	259		//

@@ -276,10 +276,10 @@ var xNewAboutDialogFromAppdata func(string, string) uintptr
276		// [property@AboutDialog:release-notes-version] is set to match it, while	276		// [property@AboutDialog:release-notes-version] is set to match it, while
277		// [property@AboutDialog:release-notes] is set from the AppStream release	277		// [property@AboutDialog:release-notes] is set from the AppStream release
278		// description for that version.	278		// description for that version.
279	-	func NewAboutDialogFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar string) *AboutDialog {	279	+	func NewAboutDialogFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar string) AboutDialog {
280		var cls *AboutDialog	280		var cls *AboutDialog
281			281
282	-	cret := xNewAboutDialogFromAppdata(ResourcePathVar, ReleaseNotesVersionVar)	282	+	cret := xNewAboutDialogFromAppdata(ResourcePathVar, core.NullableStringToPtr(ReleaseNotesVersionVar))
283			283
284		if cret == 0 {	284		if cret == 0 {
285		return nil	285		return nil

@@ -290,7 +290,7 @@ func NewAboutDialogFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar st
290		return cls	290		return cls
291		}	291		}
292			292
293	-	var xAboutDialogAddAcknowledgementSection func(uintptr, string, []string)	293	+	var xAboutDialogAddAcknowledgementSection func(uintptr, uintptr, []string)
294			294
295		// Adds a section to the Acknowledgements page.	295		// Adds a section to the Acknowledgements page.
296		//	296		//

@@ -309,13 +309,13 @@ var xAboutDialogAddAcknowledgementSection func(uintptr, string, []string)
309		// * [property@AboutDialog:documenters]	309		// * [property@AboutDialog:documenters]
310		// * [property@AboutDialog:translator-credits]	310		// * [property@AboutDialog:translator-credits]
311		// * [method@AboutDialog.add_credit_section]	311		// * [method@AboutDialog.add_credit_section]
312	-	func (x *AboutDialog) AddAcknowledgementSection(NameVar string, PeopleVar []string) {	312	+	func (x AboutDialog) AddAcknowledgementSection(NameVar string, PeopleVar []string) {
313			313
314	-	xAboutDialogAddAcknowledgementSection(x.GoPointer(), NameVar, PeopleVar)	314	+	xAboutDialogAddAcknowledgementSection(x.GoPointer(), core.NullableStringToPtr(NameVar), PeopleVar)
315			315
316		}	316		}
317			317
318	-	var xAboutDialogAddCreditSection func(uintptr, string, []string)	318	+	var xAboutDialogAddCreditSection func(uintptr, uintptr, []string)
319			319
320		// Adds an extra section to the Credits page.	320		// Adds an extra section to the Credits page.
321		//	321		//

@@ -332,13 +332,13 @@ var xAboutDialogAddCreditSection func(uintptr, string, []string)
332		// * [property@AboutDialog:documenters]	332		// * [property@AboutDialog:documenters]
333		// * [property@AboutDialog:translator-credits]	333		// * [property@AboutDialog:translator-credits]
334		// * [method@AboutDialog.add_acknowledgement_section]	334		// * [method@AboutDialog.add_acknowledgement_section]
335	-	func (x *AboutDialog) AddCreditSection(NameVar string, PeopleVar []string) {	335	+	func (x AboutDialog) AddCreditSection(NameVar string, PeopleVar []string) {
336			336
337	-	xAboutDialogAddCreditSection(x.GoPointer(), NameVar, PeopleVar)	337	+	xAboutDialogAddCreditSection(x.GoPointer(), core.NullableStringToPtr(NameVar), PeopleVar)
338			338
339		}	339		}
340			340
341	-	var xAboutDialogAddLegalSection func(uintptr, string, string, gtk.License, string)	341	+	var xAboutDialogAddLegalSection func(uintptr, string, uintptr, gtk.License, uintptr)
342			342
343		// Adds an extra section to the Legal page.	343		// Adds an extra section to the Legal page.
344		//	344		//

@@ -385,9 +385,9 @@ var xAboutDialogAddLegalSection func(uintptr, string, string, gtk.License, strin
385		// "Something completely custom here.");	385		// "Something completely custom here.");
386		//	386		//
387		// ```	387		// ```
388	-	func (x *AboutDialog) AddLegalSection(TitleVar string, CopyrightVar string, LicenseTypeVar gtk.License, LicenseVar string) {	388	+	func (x AboutDialog) AddLegalSection(TitleVar string, CopyrightVar string, LicenseTypeVar gtk.License, LicenseVar *string) {
389			389
390	-	xAboutDialogAddLegalSection(x.GoPointer(), TitleVar, CopyrightVar, LicenseTypeVar, LicenseVar)	390	+	xAboutDialogAddLegalSection(x.GoPointer(), TitleVar, core.NullableStringToPtr(CopyrightVar), LicenseTypeVar, core.NullableStringToPtr(LicenseVar))
391			391
392		}	392		}
393			393

@@ -1002,7 +1002,7 @@ func (c *AboutDialog) SetGoPointer(ptr uintptr) {
1002		func (x *AboutDialog) SetPropertyApplicationIcon(value string) {	1002		func (x *AboutDialog) SetPropertyApplicationIcon(value string) {
1003		var v gobject.Value	1003		var v gobject.Value
1004		v.Init(gobject.TypeStringVal)	1004		v.Init(gobject.TypeStringVal)
1005	-	v.SetString(value)	1005	+	v.SetString(&value)
1006		x.SetProperty("application-icon", &v)	1006		x.SetProperty("application-icon", &v)
1007		}	1007		}
1008			1008

@@ -1023,7 +1023,7 @@ func (x *AboutDialog) GetPropertyApplicationIcon() string {
1023		func (x *AboutDialog) SetPropertyApplicationName(value string) {	1023		func (x *AboutDialog) SetPropertyApplicationName(value string) {
1024		var v gobject.Value	1024		var v gobject.Value
1025		v.Init(gobject.TypeStringVal)	1025		v.Init(gobject.TypeStringVal)
1026	-	v.SetString(value)	1026	+	v.SetString(&value)
1027		x.SetProperty("application-name", &v)	1027		x.SetProperty("application-name", &v)
1028		}	1028		}
1029			1029

@@ -1092,7 +1092,7 @@ func (x *AboutDialog) GetPropertyArtists() []string {
1092		func (x *AboutDialog) SetPropertyComments(value string) {	1092		func (x *AboutDialog) SetPropertyComments(value string) {
1093		var v gobject.Value	1093		var v gobject.Value
1094		v.Init(gobject.TypeStringVal)	1094		v.Init(gobject.TypeStringVal)
1095	-	v.SetString(value)	1095	+	v.SetString(&value)
1096		x.SetProperty("comments", &v)	1096		x.SetProperty("comments", &v)
1097		}	1097		}
1098			1098

@@ -1123,7 +1123,7 @@ func (x *AboutDialog) GetPropertyComments() string {
1123		func (x *AboutDialog) SetPropertyCopyright(value string) {	1123		func (x *AboutDialog) SetPropertyCopyright(value string) {
1124		var v gobject.Value	1124		var v gobject.Value
1125		v.Init(gobject.TypeStringVal)	1125		v.Init(gobject.TypeStringVal)
1126	-	v.SetString(value)	1126	+	v.SetString(&value)
1127		x.SetProperty("copyright", &v)	1127		x.SetProperty("copyright", &v)
1128		}	1128		}
1129			1129

@@ -1159,7 +1159,7 @@ func (x *AboutDialog) GetPropertyCopyright() string {
1159		func (x *AboutDialog) SetPropertyDebugInfo(value string) {	1159		func (x *AboutDialog) SetPropertyDebugInfo(value string) {
1160		var v gobject.Value	1160		var v gobject.Value
1161		v.Init(gobject.TypeStringVal)	1161		v.Init(gobject.TypeStringVal)
1162	-	v.SetString(value)	1162	+	v.SetString(&value)
1163		x.SetProperty("debug-info", &v)	1163		x.SetProperty("debug-info", &v)
1164		}	1164		}
1165			1165

@@ -1191,7 +1191,7 @@ func (x *AboutDialog) GetPropertyDebugInfo() string {
1191		func (x *AboutDialog) SetPropertyDebugInfoFilename(value string) {	1191		func (x *AboutDialog) SetPropertyDebugInfoFilename(value string) {
1192		var v gobject.Value	1192		var v gobject.Value
1193		v.Init(gobject.TypeStringVal)	1193		v.Init(gobject.TypeStringVal)
1194	-	v.SetString(value)	1194	+	v.SetString(&value)
1195		x.SetProperty("debug-info-filename", &v)	1195		x.SetProperty("debug-info-filename", &v)
1196		}	1196		}
1197			1197

@@ -1267,7 +1267,7 @@ func (x *AboutDialog) GetPropertyDesigners() []string {
1267		func (x *AboutDialog) SetPropertyDeveloperName(value string) {	1267		func (x *AboutDialog) SetPropertyDeveloperName(value string) {
1268		var v gobject.Value	1268		var v gobject.Value
1269		v.Init(gobject.TypeStringVal)	1269		v.Init(gobject.TypeStringVal)
1270	-	v.SetString(value)	1270	+	v.SetString(&value)
1271		x.SetProperty("developer-name", &v)	1271		x.SetProperty("developer-name", &v)
1272		}	1272		}
1273			1273

@@ -1385,7 +1385,7 @@ func (x *AboutDialog) GetPropertyDocumenters() []string {
1385		func (x *AboutDialog) SetPropertyIssueUrl(value string) {	1385		func (x *AboutDialog) SetPropertyIssueUrl(value string) {
1386		var v gobject.Value	1386		var v gobject.Value
1387		v.Init(gobject.TypeStringVal)	1387		v.Init(gobject.TypeStringVal)
1388	-	v.SetString(value)	1388	+	v.SetString(&value)
1389		x.SetProperty("issue-url", &v)	1389		x.SetProperty("issue-url", &v)
1390		}	1390		}
1391			1391

@@ -1418,7 +1418,7 @@ func (x *AboutDialog) GetPropertyIssueUrl() string {
1418		func (x *AboutDialog) SetPropertyLicense(value string) {	1418		func (x *AboutDialog) SetPropertyLicense(value string) {
1419		var v gobject.Value	1419		var v gobject.Value
1420		v.Init(gobject.TypeStringVal)	1420		v.Init(gobject.TypeStringVal)
1421	-	v.SetString(value)	1421	+	v.SetString(&value)
1422		x.SetProperty("license", &v)	1422		x.SetProperty("license", &v)
1423		}	1423		}
1424			1424

@@ -1472,7 +1472,7 @@ func (x *AboutDialog) GetPropertyLicense() string {
1472		func (x *AboutDialog) SetPropertyReleaseNotes(value string) {	1472		func (x *AboutDialog) SetPropertyReleaseNotes(value string) {
1473		var v gobject.Value	1473		var v gobject.Value
1474		v.Init(gobject.TypeStringVal)	1474		v.Init(gobject.TypeStringVal)
1475	-	v.SetString(value)	1475	+	v.SetString(&value)
1476		x.SetProperty("release-notes", &v)	1476		x.SetProperty("release-notes", &v)
1477		}	1477		}
1478			1478

@@ -1523,7 +1523,7 @@ func (x *AboutDialog) GetPropertyReleaseNotes() string {
1523		func (x *AboutDialog) SetPropertyReleaseNotesVersion(value string) {	1523		func (x *AboutDialog) SetPropertyReleaseNotesVersion(value string) {
1524		var v gobject.Value	1524		var v gobject.Value
1525		v.Init(gobject.TypeStringVal)	1525		v.Init(gobject.TypeStringVal)
1526	-	v.SetString(value)	1526	+	v.SetString(&value)
1527		x.SetProperty("release-notes-version", &v)	1527		x.SetProperty("release-notes-version", &v)
1528		}	1528		}
1529			1529

@@ -1553,7 +1553,7 @@ func (x *AboutDialog) GetPropertyReleaseNotesVersion() string {
1553		func (x *AboutDialog) SetPropertySupportUrl(value string) {	1553		func (x *AboutDialog) SetPropertySupportUrl(value string) {
1554		var v gobject.Value	1554		var v gobject.Value
1555		v.Init(gobject.TypeStringVal)	1555		v.Init(gobject.TypeStringVal)
1556	-	v.SetString(value)	1556	+	v.SetString(&value)
1557		x.SetProperty("support-url", &v)	1557		x.SetProperty("support-url", &v)
1558		}	1558		}
1559			1559

@@ -1589,7 +1589,7 @@ func (x *AboutDialog) GetPropertySupportUrl() string {
1589		func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {	1589		func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {
1590		var v gobject.Value	1590		var v gobject.Value
1591		v.Init(gobject.TypeStringVal)	1591		v.Init(gobject.TypeStringVal)
1592	-	v.SetString(value)	1592	+	v.SetString(&value)
1593		x.SetProperty("translator-credits", &v)	1593		x.SetProperty("translator-credits", &v)
1594		}	1594		}
1595			1595

@@ -1628,7 +1628,7 @@ func (x *AboutDialog) GetPropertyTranslatorCredits() string {
1628		func (x *AboutDialog) SetPropertyVersion(value string) {	1628		func (x *AboutDialog) SetPropertyVersion(value string) {
1629		var v gobject.Value	1629		var v gobject.Value
1630		v.Init(gobject.TypeStringVal)	1630		v.Init(gobject.TypeStringVal)
1631	-	v.SetString(value)	1631	+	v.SetString(&value)
1632		x.SetProperty("version", &v)	1632		x.SetProperty("version", &v)
1633		}	1633		}
1634			1634

@@ -1655,7 +1655,7 @@ func (x *AboutDialog) GetPropertyVersion() string {
1655		func (x *AboutDialog) SetPropertyWebsite(value string) {	1655		func (x *AboutDialog) SetPropertyWebsite(value string) {
1656		var v gobject.Value	1656		var v gobject.Value
1657		v.Init(gobject.TypeStringVal)	1657		v.Init(gobject.TypeStringVal)
1658	-	v.SetString(value)	1658	+	v.SetString(&value)
1659		x.SetProperty("website", &v)	1659		x.SetProperty("website", &v)
1660		}	1660		}
1661			1661

M v4/adw/adw-about-window.go +30 -30


@@ -34,15 +34,15 @@ func ShowAboutWindow(ParentVar *gtk.Window, FirstPropertyNameVar string, varArgs
34			34
35		}	35		}
36			36
37	-	var xShowAboutWindowFromAppdata func(uintptr, string, string, string, ...interface{})	37	+	var xShowAboutWindowFromAppdata func(uintptr, string, uintptr, string, ...interface{})
38			38
39		// A convenience function for showing an application’s about window from	39		// A convenience function for showing an application’s about window from
40		// AppStream metadata.	40		// AppStream metadata.
41		//	41		//
42		// See [ctor@AboutWindow.new_from_appdata] for details.	42		// See [ctor@AboutWindow.new_from_appdata] for details.
43	-	func ShowAboutWindowFromAppdata(ParentVar *gtk.Window, ResourcePathVar string, ReleaseNotesVersionVar string, FirstPropertyNameVar string, varArgs ...interface{}) {	43	+	func ShowAboutWindowFromAppdata(ParentVar gtk.Window, ResourcePathVar string, ReleaseNotesVersionVar string, FirstPropertyNameVar string, varArgs ...interface{}) {
44			44
45	-	xShowAboutWindowFromAppdata(ParentVar.GoPointer(), ResourcePathVar, ReleaseNotesVersionVar, FirstPropertyNameVar, varArgs...)	45	+	xShowAboutWindowFromAppdata(ParentVar.GoPointer(), ResourcePathVar, core.NullableStringToPtr(ReleaseNotesVersionVar), FirstPropertyNameVar, varArgs...)
46			46
47		}	47		}
48			48

@@ -250,7 +250,7 @@ func NewAboutWindow() *AboutWindow {
250		return cls	250		return cls
251		}	251		}
252			252
253	-	var xNewAboutWindowFromAppdata func(string, string) uintptr	253	+	var xNewAboutWindowFromAppdata func(string, uintptr) uintptr
254			254
255		// Creates a new `AdwAboutWindow` using AppStream metadata.	255		// Creates a new `AdwAboutWindow` using AppStream metadata.
256		//	256		//

@@ -273,10 +273,10 @@ var xNewAboutWindowFromAppdata func(string, string) uintptr
273		// [property@AboutWindow:release-notes-version] is set to match it, while	273		// [property@AboutWindow:release-notes-version] is set to match it, while
274		// [property@AboutWindow:release-notes] is set from the AppStream release	274		// [property@AboutWindow:release-notes] is set from the AppStream release
275		// description for that version.	275		// description for that version.
276	-	func NewAboutWindowFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar string) *AboutWindow {	276	+	func NewAboutWindowFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar string) AboutWindow {
277		var cls *AboutWindow	277		var cls *AboutWindow
278			278
279	-	cret := xNewAboutWindowFromAppdata(ResourcePathVar, ReleaseNotesVersionVar)	279	+	cret := xNewAboutWindowFromAppdata(ResourcePathVar, core.NullableStringToPtr(ReleaseNotesVersionVar))
280			280
281		if cret == 0 {	281		if cret == 0 {
282		return nil	282		return nil

@@ -287,7 +287,7 @@ func NewAboutWindowFromAppdata(ResourcePathVar string, ReleaseNotesVersionVar st
287		return cls	287		return cls
288		}	288		}
289			289
290	-	var xAboutWindowAddAcknowledgementSection func(uintptr, string, []string)	290	+	var xAboutWindowAddAcknowledgementSection func(uintptr, uintptr, []string)
291			291
292		// Adds a section to the Acknowledgements page.	292		// Adds a section to the Acknowledgements page.
293		//	293		//

@@ -306,13 +306,13 @@ var xAboutWindowAddAcknowledgementSection func(uintptr, string, []string)
306		// * [property@AboutWindow:documenters]	306		// * [property@AboutWindow:documenters]
307		// * [property@AboutWindow:translator-credits]	307		// * [property@AboutWindow:translator-credits]
308		// * [method@AboutWindow.add_credit_section]	308		// * [method@AboutWindow.add_credit_section]
309	-	func (x *AboutWindow) AddAcknowledgementSection(NameVar string, PeopleVar []string) {	309	+	func (x AboutWindow) AddAcknowledgementSection(NameVar string, PeopleVar []string) {
310			310
311	-	xAboutWindowAddAcknowledgementSection(x.GoPointer(), NameVar, PeopleVar)	311	+	xAboutWindowAddAcknowledgementSection(x.GoPointer(), core.NullableStringToPtr(NameVar), PeopleVar)
312			312
313		}	313		}
314			314
315	-	var xAboutWindowAddCreditSection func(uintptr, string, []string)	315	+	var xAboutWindowAddCreditSection func(uintptr, uintptr, []string)
316			316
317		// Adds an extra section to the Credits page.	317		// Adds an extra section to the Credits page.
318		//	318		//

@@ -329,13 +329,13 @@ var xAboutWindowAddCreditSection func(uintptr, string, []string)
329		// * [property@AboutWindow:documenters]	329		// * [property@AboutWindow:documenters]
330		// * [property@AboutWindow:translator-credits]	330		// * [property@AboutWindow:translator-credits]
331		// * [method@AboutWindow.add_acknowledgement_section]	331		// * [method@AboutWindow.add_acknowledgement_section]
332	-	func (x *AboutWindow) AddCreditSection(NameVar string, PeopleVar []string) {	332	+	func (x AboutWindow) AddCreditSection(NameVar string, PeopleVar []string) {
333			333
334	-	xAboutWindowAddCreditSection(x.GoPointer(), NameVar, PeopleVar)	334	+	xAboutWindowAddCreditSection(x.GoPointer(), core.NullableStringToPtr(NameVar), PeopleVar)
335			335
336		}	336		}
337			337
338	-	var xAboutWindowAddLegalSection func(uintptr, string, string, gtk.License, string)	338	+	var xAboutWindowAddLegalSection func(uintptr, string, uintptr, gtk.License, uintptr)
339			339
340		// Adds an extra section to the Legal page.	340		// Adds an extra section to the Legal page.
341		//	341		//

@@ -382,9 +382,9 @@ var xAboutWindowAddLegalSection func(uintptr, string, string, gtk.License, strin
382		// "Something completely custom here.");	382		// "Something completely custom here.");
383		//	383		//
384		// ```	384		// ```
385	-	func (x *AboutWindow) AddLegalSection(TitleVar string, CopyrightVar string, LicenseTypeVar gtk.License, LicenseVar string) {	385	+	func (x AboutWindow) AddLegalSection(TitleVar string, CopyrightVar string, LicenseTypeVar gtk.License, LicenseVar *string) {
386			386
387	-	xAboutWindowAddLegalSection(x.GoPointer(), TitleVar, CopyrightVar, LicenseTypeVar, LicenseVar)	387	+	xAboutWindowAddLegalSection(x.GoPointer(), TitleVar, core.NullableStringToPtr(CopyrightVar), LicenseTypeVar, core.NullableStringToPtr(LicenseVar))
388			388
389		}	389		}
390			390

@@ -972,7 +972,7 @@ func (c *AboutWindow) SetGoPointer(ptr uintptr) {
972		func (x *AboutWindow) SetPropertyApplicationIcon(value string) {	972		func (x *AboutWindow) SetPropertyApplicationIcon(value string) {
973		var v gobject.Value	973		var v gobject.Value
974		v.Init(gobject.TypeStringVal)	974		v.Init(gobject.TypeStringVal)
975	-	v.SetString(value)	975	+	v.SetString(&value)
976		x.SetProperty("application-icon", &v)	976		x.SetProperty("application-icon", &v)
977		}	977		}
978			978

@@ -993,7 +993,7 @@ func (x *AboutWindow) GetPropertyApplicationIcon() string {
993		func (x *AboutWindow) SetPropertyApplicationName(value string) {	993		func (x *AboutWindow) SetPropertyApplicationName(value string) {
994		var v gobject.Value	994		var v gobject.Value
995		v.Init(gobject.TypeStringVal)	995		v.Init(gobject.TypeStringVal)
996	-	v.SetString(value)	996	+	v.SetString(&value)
997		x.SetProperty("application-name", &v)	997		x.SetProperty("application-name", &v)
998		}	998		}
999			999

@@ -1062,7 +1062,7 @@ func (x *AboutWindow) GetPropertyArtists() []string {
1062		func (x *AboutWindow) SetPropertyComments(value string) {	1062		func (x *AboutWindow) SetPropertyComments(value string) {
1063		var v gobject.Value	1063		var v gobject.Value
1064		v.Init(gobject.TypeStringVal)	1064		v.Init(gobject.TypeStringVal)
1065	-	v.SetString(value)	1065	+	v.SetString(&value)
1066		x.SetProperty("comments", &v)	1066		x.SetProperty("comments", &v)
1067		}	1067		}
1068			1068

@@ -1093,7 +1093,7 @@ func (x *AboutWindow) GetPropertyComments() string {
1093		func (x *AboutWindow) SetPropertyCopyright(value string) {	1093		func (x *AboutWindow) SetPropertyCopyright(value string) {
1094		var v gobject.Value	1094		var v gobject.Value
1095		v.Init(gobject.TypeStringVal)	1095		v.Init(gobject.TypeStringVal)
1096	-	v.SetString(value)	1096	+	v.SetString(&value)
1097		x.SetProperty("copyright", &v)	1097		x.SetProperty("copyright", &v)
1098		}	1098		}
1099			1099

@@ -1129,7 +1129,7 @@ func (x *AboutWindow) GetPropertyCopyright() string {
1129		func (x *AboutWindow) SetPropertyDebugInfo(value string) {	1129		func (x *AboutWindow) SetPropertyDebugInfo(value string) {
1130		var v gobject.Value	1130		var v gobject.Value
1131		v.Init(gobject.TypeStringVal)	1131		v.Init(gobject.TypeStringVal)
1132	-	v.SetString(value)	1132	+	v.SetString(&value)
1133		x.SetProperty("debug-info", &v)	1133		x.SetProperty("debug-info", &v)
1134		}	1134		}
1135			1135

@@ -1161,7 +1161,7 @@ func (x *AboutWindow) GetPropertyDebugInfo() string {
1161		func (x *AboutWindow) SetPropertyDebugInfoFilename(value string) {	1161		func (x *AboutWindow) SetPropertyDebugInfoFilename(value string) {
1162		var v gobject.Value	1162		var v gobject.Value
1163		v.Init(gobject.TypeStringVal)	1163		v.Init(gobject.TypeStringVal)
1164	-	v.SetString(value)	1164	+	v.SetString(&value)
1165		x.SetProperty("debug-info-filename", &v)	1165		x.SetProperty("debug-info-filename", &v)
1166		}	1166		}
1167			1167

@@ -1237,7 +1237,7 @@ func (x *AboutWindow) GetPropertyDesigners() []string {
1237		func (x *AboutWindow) SetPropertyDeveloperName(value string) {	1237		func (x *AboutWindow) SetPropertyDeveloperName(value string) {
1238		var v gobject.Value	1238		var v gobject.Value
1239		v.Init(gobject.TypeStringVal)	1239		v.Init(gobject.TypeStringVal)
1240	-	v.SetString(value)	1240	+	v.SetString(&value)
1241		x.SetProperty("developer-name", &v)	1241		x.SetProperty("developer-name", &v)
1242		}	1242		}
1243			1243

@@ -1355,7 +1355,7 @@ func (x *AboutWindow) GetPropertyDocumenters() []string {
1355		func (x *AboutWindow) SetPropertyIssueUrl(value string) {	1355		func (x *AboutWindow) SetPropertyIssueUrl(value string) {
1356		var v gobject.Value	1356		var v gobject.Value
1357		v.Init(gobject.TypeStringVal)	1357		v.Init(gobject.TypeStringVal)
1358	-	v.SetString(value)	1358	+	v.SetString(&value)
1359		x.SetProperty("issue-url", &v)	1359		x.SetProperty("issue-url", &v)
1360		}	1360		}
1361			1361

@@ -1388,7 +1388,7 @@ func (x *AboutWindow) GetPropertyIssueUrl() string {
1388		func (x *AboutWindow) SetPropertyLicense(value string) {	1388		func (x *AboutWindow) SetPropertyLicense(value string) {
1389		var v gobject.Value	1389		var v gobject.Value
1390		v.Init(gobject.TypeStringVal)	1390		v.Init(gobject.TypeStringVal)
1391	-	v.SetString(value)	1391	+	v.SetString(&value)
1392		x.SetProperty("license", &v)	1392		x.SetProperty("license", &v)
1393		}	1393		}
1394			1394

@@ -1442,7 +1442,7 @@ func (x *AboutWindow) GetPropertyLicense() string {
1442		func (x *AboutWindow) SetPropertyReleaseNotes(value string) {	1442		func (x *AboutWindow) SetPropertyReleaseNotes(value string) {
1443		var v gobject.Value	1443		var v gobject.Value
1444		v.Init(gobject.TypeStringVal)	1444		v.Init(gobject.TypeStringVal)
1445	-	v.SetString(value)	1445	+	v.SetString(&value)
1446		x.SetProperty("release-notes", &v)	1446		x.SetProperty("release-notes", &v)
1447		}	1447		}
1448			1448

@@ -1493,7 +1493,7 @@ func (x *AboutWindow) GetPropertyReleaseNotes() string {
1493		func (x *AboutWindow) SetPropertyReleaseNotesVersion(value string) {	1493		func (x *AboutWindow) SetPropertyReleaseNotesVersion(value string) {
1494		var v gobject.Value	1494		var v gobject.Value
1495		v.Init(gobject.TypeStringVal)	1495		v.Init(gobject.TypeStringVal)
1496	-	v.SetString(value)	1496	+	v.SetString(&value)
1497		x.SetProperty("release-notes-version", &v)	1497		x.SetProperty("release-notes-version", &v)
1498		}	1498		}
1499			1499

@@ -1523,7 +1523,7 @@ func (x *AboutWindow) GetPropertyReleaseNotesVersion() string {
1523		func (x *AboutWindow) SetPropertySupportUrl(value string) {	1523		func (x *AboutWindow) SetPropertySupportUrl(value string) {
1524		var v gobject.Value	1524		var v gobject.Value
1525		v.Init(gobject.TypeStringVal)	1525		v.Init(gobject.TypeStringVal)
1526	-	v.SetString(value)	1526	+	v.SetString(&value)
1527		x.SetProperty("support-url", &v)	1527		x.SetProperty("support-url", &v)
1528		}	1528		}
1529			1529

@@ -1559,7 +1559,7 @@ func (x *AboutWindow) GetPropertySupportUrl() string {
1559		func (x *AboutWindow) SetPropertyTranslatorCredits(value string) {	1559		func (x *AboutWindow) SetPropertyTranslatorCredits(value string) {
1560		var v gobject.Value	1560		var v gobject.Value
1561		v.Init(gobject.TypeStringVal)	1561		v.Init(gobject.TypeStringVal)
1562	-	v.SetString(value)	1562	+	v.SetString(&value)
1563		x.SetProperty("translator-credits", &v)	1563		x.SetProperty("translator-credits", &v)
1564		}	1564		}
1565			1565

@@ -1598,7 +1598,7 @@ func (x *AboutWindow) GetPropertyTranslatorCredits() string {
1598		func (x *AboutWindow) SetPropertyVersion(value string) {	1598		func (x *AboutWindow) SetPropertyVersion(value string) {
1599		var v gobject.Value	1599		var v gobject.Value
1600		v.Init(gobject.TypeStringVal)	1600		v.Init(gobject.TypeStringVal)
1601	-	v.SetString(value)	1601	+	v.SetString(&value)
1602		x.SetProperty("version", &v)	1602		x.SetProperty("version", &v)
1603		}	1603		}
1604			1604

@@ -1625,7 +1625,7 @@ func (x *AboutWindow) GetPropertyVersion() string {
1625		func (x *AboutWindow) SetPropertyWebsite(value string) {	1625		func (x *AboutWindow) SetPropertyWebsite(value string) {
1626		var v gobject.Value	1626		var v gobject.Value
1627		v.Init(gobject.TypeStringVal)	1627		v.Init(gobject.TypeStringVal)
1628	-	v.SetString(value)	1628	+	v.SetString(&value)
1629		x.SetProperty("website", &v)	1629		x.SetProperty("website", &v)
1630		}	1630		}
1631			1631

M v4/adw/adw-action-row.go +7 -7


@@ -253,12 +253,12 @@ func (x ActionRow) SetActivatableWidget(WidgetVar gtk.Widget) {
253			253
254		}	254		}
255			255
256	-	var xActionRowSetIconName func(uintptr, string)	256	+	var xActionRowSetIconName func(uintptr, uintptr)
257			257
258		// Sets the icon name for @self.	258		// Sets the icon name for @self.
259	-	func (x *ActionRow) SetIconName(IconNameVar string) {	259	+	func (x ActionRow) SetIconName(IconNameVar string) {
260			260
261	-	xActionRowSetIconName(x.GoPointer(), IconNameVar)	261	+	xActionRowSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
262			262
263		}	263		}
264			264

@@ -325,7 +325,7 @@ func (c *ActionRow) SetGoPointer(ptr uintptr) {
325		func (x *ActionRow) SetPropertyIconName(value string) {	325		func (x *ActionRow) SetPropertyIconName(value string) {
326		var v gobject.Value	326		var v gobject.Value
327		v.Init(gobject.TypeStringVal)	327		v.Init(gobject.TypeStringVal)
328	-	v.SetString(value)	328	+	v.SetString(&value)
329		x.SetProperty("icon-name", &v)	329		x.SetProperty("icon-name", &v)
330		}	330		}
331			331

@@ -345,7 +345,7 @@ func (x *ActionRow) GetPropertyIconName() string {
345		func (x *ActionRow) SetPropertySubtitle(value string) {	345		func (x *ActionRow) SetPropertySubtitle(value string) {
346		var v gobject.Value	346		var v gobject.Value
347		v.Init(gobject.TypeStringVal)	347		v.Init(gobject.TypeStringVal)
348	-	v.SetString(value)	348	+	v.SetString(&value)
349		x.SetProperty("subtitle", &v)	349		x.SetProperty("subtitle", &v)
350		}	350		}
351			351

@@ -740,9 +740,9 @@ func (x ActionRow) GetActionTargetValue() glib.Variant {
740		// containing [class@ApplicationWindow] or its associated [class@Application],	740		// containing [class@ApplicationWindow] or its associated [class@Application],
741		// respectively. This is the same form used for actions in the [class@Gio.Menu]	741		// respectively. This is the same form used for actions in the [class@Gio.Menu]
742		// associated with the window.	742		// associated with the window.
743	-	func (x *ActionRow) SetActionName(ActionNameVar string) {	743	+	func (x ActionRow) SetActionName(ActionNameVar string) {
744			744
745	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	745	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
746			746
747		}	747		}
748			748

M v4/adw/adw-alert-dialog.go +52 -14

 package adw
 import (
+	"fmt"
 	"structs"
 	"unsafe"
 	return cls
 }
-var xNewAlertDialog func(string, string) uintptr
+var xNewAlertDialog func(uintptr, uintptr) uintptr
 // Creates a new `AdwAlertDialog`.
 //
 //	filename);
 //
 // ```
-func NewAlertDialog(HeadingVar string, BodyVar string) *AlertDialog {
+func NewAlertDialog(HeadingVar *string, BodyVar *string) *AlertDialog {
 	var cls *AlertDialog
-	cret := xNewAlertDialog(HeadingVar, BodyVar)
+	cret := xNewAlertDialog(core.NullableStringToPtr(HeadingVar), core.NullableStringToPtr(BodyVar))
 	if cret == 0 {
 		return nil
 // will be shown within it. Otherwise, it will be a separate window.
 func (x *AlertDialog) Choose(ParentVar *gtk.Widget, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 }
-var xAlertDialogSetDefaultResponse func(uintptr, string)
+var xAlertDialogSetDefaultResponse func(uintptr, uintptr)
 // Sets the ID of the default response of @self.
 //
 // will be focused by default.
 //
 // See [property@Dialog:default-widget].
-func (x *AlertDialog) SetDefaultResponse(ResponseVar string) {
+func (x *AlertDialog) SetDefaultResponse(ResponseVar *string) {
-	xAlertDialogSetDefaultResponse(x.GoPointer(), ResponseVar)
+	xAlertDialogSetDefaultResponse(x.GoPointer(), core.NullableStringToPtr(ResponseVar))
 }
 }
-var xAlertDialogSetHeading func(uintptr, string)
+var xAlertDialogSetHeading func(uintptr, uintptr)
 // Sets the heading of @self.
-func (x *AlertDialog) SetHeading(HeadingVar string) {
+func (x *AlertDialog) SetHeading(HeadingVar *string) {
-	xAlertDialogSetHeading(x.GoPointer(), HeadingVar)
+	xAlertDialogSetHeading(x.GoPointer(), core.NullableStringToPtr(HeadingVar))
 }
 func (x *AlertDialog) SetPropertyBody(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("body", &v)
 }
 func (x *AlertDialog) SetPropertyCloseResponse(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("close-response", &v)
 }
 func (x *AlertDialog) SetPropertyDefaultResponse(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("default-response", &v)
 }
 func (x *AlertDialog) SetPropertyHeading(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("heading", &v)
 }
 	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
+// ConnectResponseWithDetail connects to the "response" signal with a detail string.
+// The detail is appended as "response::<detail>".
+func (x *AlertDialog) ConnectResponseWithDetail(detail string, cb *func(AlertDialog, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	signalName := fmt.Sprintf("response::%s", detail)
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	}
+	fcb := func(clsPtr uintptr, ResponseVarp string) {
+		fa := AlertDialog{}
+		fa.Ptr = clsPtr
+		cbFn := *cb
+		cbFn(fa, ResponseVarp)
+	}
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+}
 // Requests the user's screen reader to announce the given message.
 //
 // This kind of notification is useful for messages that

M v4/adw/adw-animation-target.go +31 -1


@@ -92,7 +92,37 @@ var xNewCallbackAnimationTarget func(uintptr, uintptr, uintptr) uintptr
92		func NewCallbackAnimationTarget(CallbackVar AnimationTargetFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAnimationTarget {	92		func NewCallbackAnimationTarget(CallbackVar AnimationTargetFunc, UserDataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAnimationTarget {
93		var cls *CallbackAnimationTarget	93		var cls *CallbackAnimationTarget
94			94
95	-	cret := xNewCallbackAnimationTarget(glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DestroyVar))	95	+	var CallbackVarRef uintptr
			96	+	if CallbackVar != nil {
			97	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			98	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			99	+	CallbackVarRef = cbRefPtr
			100	+	} else {
			101	+	fcb := func(arg0 float64, arg1 uintptr) {
			102	+	cbFn := *CallbackVar
			103	+	cbFn(arg0, arg1)
			104	+	}
			105	+	CallbackVarRef = purego.NewCallback(fcb)
			106	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			107	+	}
			108	+	}
			109	+
			110	+	var DestroyVarRef uintptr
			111	+	if DestroyVar != nil {
			112	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			113	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			114	+	DestroyVarRef = cbRefPtr
			115	+	} else {
			116	+	fcb := func(arg0 uintptr) {
			117	+	cbFn := *DestroyVar
			118	+	cbFn(arg0)
			119	+	}
			120	+	DestroyVarRef = purego.NewCallback(fcb)
			121	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			122	+	}
			123	+	}
			124	+
			125	+	cret := xNewCallbackAnimationTarget(CallbackVarRef, UserDataVar, DestroyVarRef)
96			126
97		if cret == 0 {	127		if cret == 0 {
98		return nil	128		return nil

M v4/adw/adw-application.go +3 -3


@@ -86,7 +86,7 @@ func ApplicationNewFromInternalPtr(ptr uintptr) *Application {
86		return cls	86		return cls
87		}	87		}
88			88
89	-	var xNewApplication func(string, gio.ApplicationFlags) uintptr	89	+	var xNewApplication func(uintptr, gio.ApplicationFlags) uintptr
90			90
91		// Creates a new `AdwApplication`.	91		// Creates a new `AdwApplication`.
92		//	92		//

@@ -95,10 +95,10 @@ var xNewApplication func(string, gio.ApplicationFlags) uintptr
95		//	95		//
96		// If no application ID is given then some features (most notably application	96		// If no application ID is given then some features (most notably application
97		// uniqueness) will be disabled.	97		// uniqueness) will be disabled.
98	-	func NewApplication(ApplicationIdVar string, FlagsVar gio.ApplicationFlags) *Application {	98	+	func NewApplication(ApplicationIdVar string, FlagsVar gio.ApplicationFlags) Application {
99		var cls *Application	99		var cls *Application
100			100
101	-	cret := xNewApplication(ApplicationIdVar, FlagsVar)	101	+	cret := xNewApplication(core.NullableStringToPtr(ApplicationIdVar), FlagsVar)
102			102
103		if cret == 0 {	103		if cret == 0 {
104		return nil	104		return nil

M v4/adw/adw-avatar.go +11 -11


@@ -68,13 +68,13 @@ func AvatarNewFromInternalPtr(ptr uintptr) *Avatar {
68		return cls	68		return cls
69		}	69		}
70			70
71	-	var xNewAvatar func(int, string, bool) uintptr	71	+	var xNewAvatar func(int, uintptr, bool) uintptr
72			72
73		// Creates a new `AdwAvatar`.	73		// Creates a new `AdwAvatar`.
74	-	func NewAvatar(SizeVar int, TextVar string, ShowInitialsVar bool) *Avatar {	74	+	func NewAvatar(SizeVar int, TextVar string, ShowInitialsVar bool) Avatar {
75		var cls *Avatar	75		var cls *Avatar
76			76
77	-	cret := xNewAvatar(SizeVar, TextVar, ShowInitialsVar)	77	+	cret := xNewAvatar(SizeVar, core.NullableStringToPtr(TextVar), ShowInitialsVar)
78			78
79		if cret == 0 {	79		if cret == 0 {
80		return nil	80		return nil

@@ -167,14 +167,14 @@ func (x *Avatar) SetCustomImage(CustomImageVar gdk.Paintable) {
167			167
168		}	168		}
169			169
170	-	var xAvatarSetIconName func(uintptr, string)	170	+	var xAvatarSetIconName func(uintptr, uintptr)
171			171
172		// Sets the name of an icon to use as a fallback.	172		// Sets the name of an icon to use as a fallback.
173		//	173		//
174		// If no name is set, `avatar-default-symbolic` will be used.	174		// If no name is set, `avatar-default-symbolic` will be used.
175	-	func (x *Avatar) SetIconName(IconNameVar string) {	175	+	func (x Avatar) SetIconName(IconNameVar string) {
176			176
177	-	xAvatarSetIconName(x.GoPointer(), IconNameVar)	177	+	xAvatarSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
178			178
179		}	179		}
180			180

@@ -198,15 +198,15 @@ func (x *Avatar) SetSize(SizeVar int) {
198			198
199		}	199		}
200			200
201	-	var xAvatarSetText func(uintptr, string)	201	+	var xAvatarSetText func(uintptr, uintptr)
202			202
203		// Sets the text used to generate the fallback initials and color.	203		// Sets the text used to generate the fallback initials and color.
204		//	204		//
205		// It's only used to generate the color if [property@Avatar:show-initials] is	205		// It's only used to generate the color if [property@Avatar:show-initials] is
206		// `FALSE`.	206		// `FALSE`.
207	-	func (x *Avatar) SetText(TextVar string) {	207	+	func (x Avatar) SetText(TextVar string) {
208			208
209	-	xAvatarSetText(x.GoPointer(), TextVar)	209	+	xAvatarSetText(x.GoPointer(), core.NullableStringToPtr(TextVar))
210			210
211		}	211		}
212			212

@@ -228,7 +228,7 @@ func (c *Avatar) SetGoPointer(ptr uintptr) {
228		func (x *Avatar) SetPropertyIconName(value string) {	228		func (x *Avatar) SetPropertyIconName(value string) {
229		var v gobject.Value	229		var v gobject.Value
230		v.Init(gobject.TypeStringVal)	230		v.Init(gobject.TypeStringVal)
231	-	v.SetString(value)	231	+	v.SetString(&value)
232		x.SetProperty("icon-name", &v)	232		x.SetProperty("icon-name", &v)
233		}	233		}
234			234

@@ -288,7 +288,7 @@ func (x *Avatar) GetPropertySize() int {
288		func (x *Avatar) SetPropertyText(value string) {	288		func (x *Avatar) SetPropertyText(value string) {
289		var v gobject.Value	289		var v gobject.Value
290		v.Init(gobject.TypeStringVal)	290		v.Init(gobject.TypeStringVal)
291	-	v.SetString(value)	291	+	v.SetString(&value)
292		x.SetProperty("text", &v)	292		x.SetProperty("text", &v)
293		}	293		}
294			294

M v4/adw/adw-banner.go +7 -7


@@ -154,7 +154,7 @@ func (x *Banner) GetUseMarkup() bool {
154		return cret	154		return cret
155		}	155		}
156			156
157	-	var xBannerSetButtonLabel func(uintptr, string)	157	+	var xBannerSetButtonLabel func(uintptr, uintptr)
158			158
159		// Sets the button label for @self.	159		// Sets the button label for @self.
160		//	160		//

@@ -162,9 +162,9 @@ var xBannerSetButtonLabel func(uintptr, string)
162		//	162		//
163		// The button can be used with a `GAction`, or with the	163		// The button can be used with a `GAction`, or with the
164		// [signal@Banner::button-clicked] signal.	164		// [signal@Banner::button-clicked] signal.
165	-	func (x *Banner) SetButtonLabel(LabelVar string) {	165	+	func (x Banner) SetButtonLabel(LabelVar string) {
166			166
167	-	xBannerSetButtonLabel(x.GoPointer(), LabelVar)	167	+	xBannerSetButtonLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
168			168
169		}	169		}
170			170

@@ -239,7 +239,7 @@ func (c *Banner) SetGoPointer(ptr uintptr) {
239		func (x *Banner) SetPropertyButtonLabel(value string) {	239		func (x *Banner) SetPropertyButtonLabel(value string) {
240		var v gobject.Value	240		var v gobject.Value
241		v.Init(gobject.TypeStringVal)	241		v.Init(gobject.TypeStringVal)
242	-	v.SetString(value)	242	+	v.SetString(&value)
243		x.SetProperty("button-label", &v)	243		x.SetProperty("button-label", &v)
244		}	244		}
245			245

@@ -280,7 +280,7 @@ func (x *Banner) GetPropertyRevealed() bool {
280		func (x *Banner) SetPropertyTitle(value string) {	280		func (x *Banner) SetPropertyTitle(value string) {
281		var v gobject.Value	281		var v gobject.Value
282		v.Init(gobject.TypeStringVal)	282		v.Init(gobject.TypeStringVal)
283	-	v.SetString(value)	283	+	v.SetString(&value)
284		x.SetProperty("title", &v)	284		x.SetProperty("title", &v)
285		}	285		}
286			286

@@ -632,9 +632,9 @@ func (x Banner) GetActionTargetValue() glib.Variant {
632		// containing [class@ApplicationWindow] or its associated [class@Application],	632		// containing [class@ApplicationWindow] or its associated [class@Application],
633		// respectively. This is the same form used for actions in the [class@Gio.Menu]	633		// respectively. This is the same form used for actions in the [class@Gio.Menu]
634		// associated with the window.	634		// associated with the window.
635	-	func (x *Banner) SetActionName(ActionNameVar string) {	635	+	func (x Banner) SetActionName(ActionNameVar string) {
636			636
637	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	637	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
638			638
639		}	639		}
640			640

M v4/adw/adw-button-content.go +2 -2


@@ -233,7 +233,7 @@ func (x *ButtonContent) GetPropertyCanShrink() bool {
233		func (x *ButtonContent) SetPropertyIconName(value string) {	233		func (x *ButtonContent) SetPropertyIconName(value string) {
234		var v gobject.Value	234		var v gobject.Value
235		v.Init(gobject.TypeStringVal)	235		v.Init(gobject.TypeStringVal)
236	-	v.SetString(value)	236	+	v.SetString(&value)
237		x.SetProperty("icon-name", &v)	237		x.SetProperty("icon-name", &v)
238		}	238		}
239			239

@@ -252,7 +252,7 @@ func (x *ButtonContent) GetPropertyIconName() string {
252		func (x *ButtonContent) SetPropertyLabel(value string) {	252		func (x *ButtonContent) SetPropertyLabel(value string) {
253		var v gobject.Value	253		var v gobject.Value
254		v.Init(gobject.TypeStringVal)	254		v.Init(gobject.TypeStringVal)
255	-	v.SetString(value)	255	+	v.SetString(&value)
256		x.SetProperty("label", &v)	256		x.SetProperty("label", &v)
257		}	257		}
258			258

M v4/adw/adw-button-row.go +10 -10


@@ -124,21 +124,21 @@ func (x *ButtonRow) GetStartIconName() string {
124		return cret	124		return cret
125		}	125		}
126			126
127	-	var xButtonRowSetEndIconName func(uintptr, string)	127	+	var xButtonRowSetEndIconName func(uintptr, uintptr)
128			128
129		// Sets the end icon name for @self.	129		// Sets the end icon name for @self.
130	-	func (x *ButtonRow) SetEndIconName(IconNameVar string) {	130	+	func (x ButtonRow) SetEndIconName(IconNameVar string) {
131			131
132	-	xButtonRowSetEndIconName(x.GoPointer(), IconNameVar)	132	+	xButtonRowSetEndIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
133			133
134		}	134		}
135			135
136	-	var xButtonRowSetStartIconName func(uintptr, string)	136	+	var xButtonRowSetStartIconName func(uintptr, uintptr)
137			137
138		// Sets the start icon name for @self.	138		// Sets the start icon name for @self.
139	-	func (x *ButtonRow) SetStartIconName(IconNameVar string) {	139	+	func (x ButtonRow) SetStartIconName(IconNameVar string) {
140			140
141	-	xButtonRowSetStartIconName(x.GoPointer(), IconNameVar)	141	+	xButtonRowSetStartIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
142			142
143		}	143		}
144			144

@@ -158,7 +158,7 @@ func (c *ButtonRow) SetGoPointer(ptr uintptr) {
158		func (x *ButtonRow) SetPropertyEndIconName(value string) {	158		func (x *ButtonRow) SetPropertyEndIconName(value string) {
159		var v gobject.Value	159		var v gobject.Value
160		v.Init(gobject.TypeStringVal)	160		v.Init(gobject.TypeStringVal)
161	-	v.SetString(value)	161	+	v.SetString(&value)
162		x.SetProperty("end-icon-name", &v)	162		x.SetProperty("end-icon-name", &v)
163		}	163		}
164			164

@@ -175,7 +175,7 @@ func (x *ButtonRow) GetPropertyEndIconName() string {
175		func (x *ButtonRow) SetPropertyStartIconName(value string) {	175		func (x *ButtonRow) SetPropertyStartIconName(value string) {
176		var v gobject.Value	176		var v gobject.Value
177		v.Init(gobject.TypeStringVal)	177		v.Init(gobject.TypeStringVal)
178	-	v.SetString(value)	178	+	v.SetString(&value)
179		x.SetProperty("start-icon-name", &v)	179		x.SetProperty("start-icon-name", &v)
180		}	180		}
181			181

@@ -502,9 +502,9 @@ func (x ButtonRow) GetActionTargetValue() glib.Variant {
502		// containing [class@ApplicationWindow] or its associated [class@Application],	502		// containing [class@ApplicationWindow] or its associated [class@Application],
503		// respectively. This is the same form used for actions in the [class@Gio.Menu]	503		// respectively. This is the same form used for actions in the [class@Gio.Menu]
504		// associated with the window.	504		// associated with the window.
505	-	func (x *ButtonRow) SetActionName(ActionNameVar string) {	505	+	func (x ButtonRow) SetActionName(ActionNameVar string) {
506			506
507	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	507	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
508			508
509		}	509		}
510			510

M v4/adw/adw-combo-row.go +2 -2


@@ -747,9 +747,9 @@ func (x ComboRow) GetActionTargetValue() glib.Variant {
747		// containing [class@ApplicationWindow] or its associated [class@Application],	747		// containing [class@ApplicationWindow] or its associated [class@Application],
748		// respectively. This is the same form used for actions in the [class@Gio.Menu]	748		// respectively. This is the same form used for actions in the [class@Gio.Menu]
749		// associated with the window.	749		// associated with the window.
750	-	func (x *ComboRow) SetActionName(ActionNameVar string) {	750	+	func (x ComboRow) SetActionName(ActionNameVar string) {
751			751
752	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	752	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
753			753
754		}	754		}
755			755

M v4/adw/adw-dialog.go +1 -1


@@ -605,7 +605,7 @@ func (x *Dialog) GetPropertyFollowsContentSize() bool {
605		func (x *Dialog) SetPropertyTitle(value string) {	605		func (x *Dialog) SetPropertyTitle(value string) {
606		var v gobject.Value	606		var v gobject.Value
607		v.Init(gobject.TypeStringVal)	607		v.Init(gobject.TypeStringVal)
608	-	v.SetString(value)	608	+	v.SetString(&value)
609		x.SetProperty("title", &v)	609		x.SetProperty("title", &v)
610		}	610		}
611			611

M v4/adw/adw-entry-row.go +2 -2


@@ -752,9 +752,9 @@ func (x EntryRow) GetActionTargetValue() glib.Variant {
752		// containing [class@ApplicationWindow] or its associated [class@Application],	752		// containing [class@ApplicationWindow] or its associated [class@Application],
753		// respectively. This is the same form used for actions in the [class@Gio.Menu]	753		// respectively. This is the same form used for actions in the [class@Gio.Menu]
754		// associated with the window.	754		// associated with the window.
755	-	func (x *EntryRow) SetActionName(ActionNameVar string) {	755	+	func (x EntryRow) SetActionName(ActionNameVar string) {
756			756
757	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	757	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
758			758
759		}	759		}
760			760

M v4/adw/adw-expander-row.go +7 -7


@@ -227,12 +227,12 @@ func (x *ExpanderRow) SetExpanded(ExpandedVar bool) {
227			227
228		}	228		}
229			229
230	-	var xExpanderRowSetIconName func(uintptr, string)	230	+	var xExpanderRowSetIconName func(uintptr, uintptr)
231			231
232		// Sets the icon name for @self.	232		// Sets the icon name for @self.
233	-	func (x *ExpanderRow) SetIconName(IconNameVar string) {	233	+	func (x ExpanderRow) SetIconName(IconNameVar string) {
234			234
235	-	xExpanderRowSetIconName(x.GoPointer(), IconNameVar)	235	+	xExpanderRowSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
236			236
237		}	237		}
238			238

@@ -331,7 +331,7 @@ func (x *ExpanderRow) GetPropertyExpanded() bool {
331		func (x *ExpanderRow) SetPropertyIconName(value string) {	331		func (x *ExpanderRow) SetPropertyIconName(value string) {
332		var v gobject.Value	332		var v gobject.Value
333		v.Init(gobject.TypeStringVal)	333		v.Init(gobject.TypeStringVal)
334	-	v.SetString(value)	334	+	v.SetString(&value)
335		x.SetProperty("icon-name", &v)	335		x.SetProperty("icon-name", &v)
336		}	336		}
337			337

@@ -368,7 +368,7 @@ func (x *ExpanderRow) GetPropertyShowEnableSwitch() bool {
368		func (x *ExpanderRow) SetPropertySubtitle(value string) {	368		func (x *ExpanderRow) SetPropertySubtitle(value string) {
369		var v gobject.Value	369		var v gobject.Value
370		v.Init(gobject.TypeStringVal)	370		v.Init(gobject.TypeStringVal)
371	-	v.SetString(value)	371	+	v.SetString(&value)
372		x.SetProperty("subtitle", &v)	372		x.SetProperty("subtitle", &v)
373		}	373		}
374			374

@@ -722,9 +722,9 @@ func (x ExpanderRow) GetActionTargetValue() glib.Variant {
722		// containing [class@ApplicationWindow] or its associated [class@Application],	722		// containing [class@ApplicationWindow] or its associated [class@Application],
723		// respectively. This is the same form used for actions in the [class@Gio.Menu]	723		// respectively. This is the same form used for actions in the [class@Gio.Menu]
724		// associated with the window.	724		// associated with the window.
725	-	func (x *ExpanderRow) SetActionName(ActionNameVar string) {	725	+	func (x ExpanderRow) SetActionName(ActionNameVar string) {
726			726
727	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	727	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
728			728
729		}	729		}
730			730

M v4/adw/adw-header-bar.go +4 -4


@@ -280,7 +280,7 @@ func (x *HeaderBar) SetCenteringPolicy(CenteringPolicyVar CenteringPolicy) {
280			280
281		}	281		}
282			282
283	-	var xHeaderBarSetDecorationLayout func(uintptr, string)	283	+	var xHeaderBarSetDecorationLayout func(uintptr, uintptr)
284			284
285		// Sets the decoration layout for @self.	285		// Sets the decoration layout for @self.
286		//	286		//

@@ -294,9 +294,9 @@ var xHeaderBarSetDecorationLayout func(uintptr, string)
294		//	294		//
295		// For example, “icon:minimize,maximize,close” specifies an icon at the start,	295		// For example, “icon:minimize,maximize,close” specifies an icon at the start,
296		// and minimize, maximize and close buttons at the end.	296		// and minimize, maximize and close buttons at the end.
297	-	func (x *HeaderBar) SetDecorationLayout(LayoutVar string) {	297	+	func (x HeaderBar) SetDecorationLayout(LayoutVar string) {
298			298
299	-	xHeaderBarSetDecorationLayout(x.GoPointer(), LayoutVar)	299	+	xHeaderBarSetDecorationLayout(x.GoPointer(), core.NullableStringToPtr(LayoutVar))
300			300
301		}	301		}
302			302

@@ -404,7 +404,7 @@ func (c *HeaderBar) SetGoPointer(ptr uintptr) {
404		func (x *HeaderBar) SetPropertyDecorationLayout(value string) {	404		func (x *HeaderBar) SetPropertyDecorationLayout(value string) {
405		var v gobject.Value	405		var v gobject.Value
406		v.Init(gobject.TypeStringVal)	406		v.Init(gobject.TypeStringVal)
407	-	v.SetString(value)	407	+	v.SetString(&value)
408		x.SetProperty("decoration-layout", &v)	408		x.SetProperty("decoration-layout", &v)
409		}	409		}
410			410

M v4/adw/adw-layout-slot.go +1 -1


@@ -88,7 +88,7 @@ func (c *LayoutSlot) SetGoPointer(ptr uintptr) {
88		func (x *LayoutSlot) SetPropertyId(value string) {	88		func (x *LayoutSlot) SetPropertyId(value string) {
89		var v gobject.Value	89		var v gobject.Value
90		v.Init(gobject.TypeStringVal)	90		v.Init(gobject.TypeStringVal)
91	-	v.SetString(value)	91	+	v.SetString(&value)
92		x.SetProperty("id", &v)	92		x.SetProperty("id", &v)
93		}	93		}
94			94

M v4/adw/adw-layout.go +4 -4


@@ -81,12 +81,12 @@ func (x *Layout) GetName() string {
81		return cret	81		return cret
82		}	82		}
83			83
84	-	var xLayoutSetName func(uintptr, string)	84	+	var xLayoutSetName func(uintptr, uintptr)
85			85
86		// Sets the name of the layout.	86		// Sets the name of the layout.
87	-	func (x *Layout) SetName(NameVar string) {	87	+	func (x Layout) SetName(NameVar string) {
88			88
89	-	xLayoutSetName(x.GoPointer(), NameVar)	89	+	xLayoutSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
90			90
91		}	91		}
92			92

@@ -106,7 +106,7 @@ func (c *Layout) SetGoPointer(ptr uintptr) {
106		func (x *Layout) SetPropertyName(value string) {	106		func (x *Layout) SetPropertyName(value string) {
107		var v gobject.Value	107		var v gobject.Value
108		v.Init(gobject.TypeStringVal)	108		v.Init(gobject.TypeStringVal)
109	-	v.SetString(value)	109	+	v.SetString(&value)
110		x.SetProperty("name", &v)	110		x.SetProperty("name", &v)
111		}	111		}
112			112

M v4/adw/adw-leaflet.go +5 -5


@@ -783,7 +783,7 @@ func (x *Leaflet) GetPropertyModeTransitionDuration() uint {
783		func (x *Leaflet) SetPropertyVisibleChildName(value string) {	783		func (x *Leaflet) SetPropertyVisibleChildName(value string) {
784		var v gobject.Value	784		var v gobject.Value
785		v.Init(gobject.TypeStringVal)	785		v.Init(gobject.TypeStringVal)
786	-	v.SetString(value)	786	+	v.SetString(&value)
787		x.SetProperty("visible-child-name", &v)	787		x.SetProperty("visible-child-name", &v)
788		}	788		}
789			789

@@ -1189,12 +1189,12 @@ func (x *LeafletPage) GetNavigatable() bool {
1189		return cret	1189		return cret
1190		}	1190		}
1191			1191
1192	-	var xLeafletPageSetName func(uintptr, string)	1192	+	var xLeafletPageSetName func(uintptr, uintptr)
1193			1193
1194		// Sets the name of the @self.	1194		// Sets the name of the @self.
1195	-	func (x *LeafletPage) SetName(NameVar string) {	1195	+	func (x LeafletPage) SetName(NameVar string) {
1196			1196
1197	-	xLeafletPageSetName(x.GoPointer(), NameVar)	1197	+	xLeafletPageSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
1198			1198
1199		}	1199		}
1200			1200

@@ -1228,7 +1228,7 @@ func (c *LeafletPage) SetGoPointer(ptr uintptr) {
1228		func (x *LeafletPage) SetPropertyName(value string) {	1228		func (x *LeafletPage) SetPropertyName(value string) {
1229		var v gobject.Value	1229		var v gobject.Value
1230		v.Init(gobject.TypeStringVal)	1230		v.Init(gobject.TypeStringVal)
1231	-	v.SetString(value)	1231	+	v.SetString(&value)
1232		x.SetProperty("name", &v)	1232		x.SetProperty("name", &v)
1233		}	1233		}
1234			1234

M v4/adw/adw-message-dialog.go +52 -14

 package adw
 import (
+	"fmt"
 	"structs"
 	"unsafe"
 	return cls
 }
-var xNewMessageDialog func(uintptr, string, string) uintptr
+var xNewMessageDialog func(uintptr, uintptr, uintptr) uintptr
 // Creates a new `AdwMessageDialog`.
 //
 //	filename);
 //
 // ```
-func NewMessageDialog(ParentVar *gtk.Window, HeadingVar string, BodyVar string) *MessageDialog {
+func NewMessageDialog(ParentVar *gtk.Window, HeadingVar *string, BodyVar *string) *MessageDialog {
 	var cls *MessageDialog
-	cret := xNewMessageDialog(ParentVar.GoPointer(), HeadingVar, BodyVar)
+	cret := xNewMessageDialog(ParentVar.GoPointer(), core.NullableStringToPtr(HeadingVar), core.NullableStringToPtr(BodyVar))
 	if cret == 0 {
 		return nil
 // This function shows @self to the user.
 func (x *MessageDialog) Choose(CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xMessageDialogChoose(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 }
-var xMessageDialogSetDefaultResponse func(uintptr, string)
+var xMessageDialogSetDefaultResponse func(uintptr, uintptr)
 // Sets the ID of the default response of @self.
 //
 // will be focused by default.
 //
 // See [property@Gtk.Window:default-widget].
-func (x *MessageDialog) SetDefaultResponse(ResponseVar string) {
+func (x *MessageDialog) SetDefaultResponse(ResponseVar *string) {
-	xMessageDialogSetDefaultResponse(x.GoPointer(), ResponseVar)
+	xMessageDialogSetDefaultResponse(x.GoPointer(), core.NullableStringToPtr(ResponseVar))
 }
 }
-var xMessageDialogSetHeading func(uintptr, string)
+var xMessageDialogSetHeading func(uintptr, uintptr)
 // Sets the heading of @self.
-func (x *MessageDialog) SetHeading(HeadingVar string) {
+func (x *MessageDialog) SetHeading(HeadingVar *string) {
-	xMessageDialogSetHeading(x.GoPointer(), HeadingVar)
+	xMessageDialogSetHeading(x.GoPointer(), core.NullableStringToPtr(HeadingVar))
 }
 func (x *MessageDialog) SetPropertyBody(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("body", &v)
 }
 func (x *MessageDialog) SetPropertyCloseResponse(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("close-response", &v)
 }
 func (x *MessageDialog) SetPropertyDefaultResponse(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("default-response", &v)
 }
 func (x *MessageDialog) SetPropertyHeading(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("heading", &v)
 }
 	return gobject.SignalConnect(x.GoPointer(), "response", cbRefPtr)
 }
+// ConnectResponseWithDetail connects to the "response" signal with a detail string.
+// The detail is appended as "response::<detail>".
+func (x *MessageDialog) ConnectResponseWithDetail(detail string, cb *func(MessageDialog, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	signalName := fmt.Sprintf("response::%s", detail)
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	}
+	fcb := func(clsPtr uintptr, ResponseVarp string) {
+		fa := MessageDialog{}
+		fa.Ptr = clsPtr
+		cbFn := *cb
+		cbFn(fa, ResponseVarp)
+	}
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+}
 // Requests the user's screen reader to announce the given message.
 //
 // This kind of notification is useful for messages that

M v4/adw/adw-multi-layout-view.go +1 -1


@@ -266,7 +266,7 @@ func (c *MultiLayoutView) SetGoPointer(ptr uintptr) {
266		func (x *MultiLayoutView) SetPropertyLayoutName(value string) {	266		func (x *MultiLayoutView) SetPropertyLayoutName(value string) {
267		var v gobject.Value	267		var v gobject.Value
268		v.Init(gobject.TypeStringVal)	268		v.Init(gobject.TypeStringVal)
269	-	v.SetString(value)	269	+	v.SetString(&value)
270		x.SetProperty("layout-name", &v)	270		x.SetProperty("layout-name", &v)
271		}	271		}
272			272

M v4/adw/adw-navigation-view.go +5 -5


@@ -284,7 +284,7 @@ func (x NavigationPage) SetChild(ChildVar gtk.Widget) {
284			284
285		}	285		}
286			286
287	-	var xNavigationPageSetTag func(uintptr, string)	287	+	var xNavigationPageSetTag func(uintptr, uintptr)
288			288
289		// Sets the tag for @self.	289		// Sets the tag for @self.
290		//	290		//

@@ -296,9 +296,9 @@ var xNavigationPageSetTag func(uintptr, string)
296		// Tags must be unique within each [class@NavigationView].	296		// Tags must be unique within each [class@NavigationView].
297		//	297		//
298		// The tag also must be set to use the `navigation.push` action.	298		// The tag also must be set to use the `navigation.push` action.
299	-	func (x *NavigationPage) SetTag(TagVar string) {	299	+	func (x NavigationPage) SetTag(TagVar string) {
300			300
301	-	xNavigationPageSetTag(x.GoPointer(), TagVar)	301	+	xNavigationPageSetTag(x.GoPointer(), core.NullableStringToPtr(TagVar))
302			302
303		}	303		}
304			304

@@ -374,7 +374,7 @@ func (x *NavigationPage) GetPropertyCanPop() bool {
374		func (x *NavigationPage) SetPropertyTag(value string) {	374		func (x *NavigationPage) SetPropertyTag(value string) {
375		var v gobject.Value	375		var v gobject.Value
376		v.Init(gobject.TypeStringVal)	376		v.Init(gobject.TypeStringVal)
377	-	v.SetString(value)	377	+	v.SetString(&value)
378		x.SetProperty("tag", &v)	378		x.SetProperty("tag", &v)
379		}	379		}
380			380

@@ -403,7 +403,7 @@ func (x *NavigationPage) GetPropertyTag() string {
403		func (x *NavigationPage) SetPropertyTitle(value string) {	403		func (x *NavigationPage) SetPropertyTitle(value string) {
404		var v gobject.Value	404		var v gobject.Value
405		v.Init(gobject.TypeStringVal)	405		v.Init(gobject.TypeStringVal)
406	-	v.SetString(value)	406	+	v.SetString(&value)
407		x.SetProperty("title", &v)	407		x.SetProperty("title", &v)
408		}	408		}
409			409

M v4/adw/adw-password-entry-row.go +2 -2


@@ -383,9 +383,9 @@ func (x PasswordEntryRow) GetActionTargetValue() glib.Variant {
383		// containing [class@ApplicationWindow] or its associated [class@Application],	383		// containing [class@ApplicationWindow] or its associated [class@Application],
384		// respectively. This is the same form used for actions in the [class@Gio.Menu]	384		// respectively. This is the same form used for actions in the [class@Gio.Menu]
385		// associated with the window.	385		// associated with the window.
386	-	func (x *PasswordEntryRow) SetActionName(ActionNameVar string) {	386	+	func (x PasswordEntryRow) SetActionName(ActionNameVar string) {
387			387
388	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	388	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
389			389
390		}	390		}
391			391

M v4/adw/adw-preferences-dialog.go +1 -1


@@ -227,7 +227,7 @@ func (x *PreferencesDialog) GetPropertySearchEnabled() bool {
227		func (x *PreferencesDialog) SetPropertyVisiblePageName(value string) {	227		func (x *PreferencesDialog) SetPropertyVisiblePageName(value string) {
228		var v gobject.Value	228		var v gobject.Value
229		v.Init(gobject.TypeStringVal)	229		v.Init(gobject.TypeStringVal)
230	-	v.SetString(value)	230	+	v.SetString(&value)
231		x.SetProperty("visible-page-name", &v)	231		x.SetProperty("visible-page-name", &v)
232		}	232		}
233			233

M v4/adw/adw-preferences-group.go +36 -6

 // See [method@Gtk.ListBox.bind_model].
 func (x *PreferencesGroup) BindModel(ModelVar gio.ListModel, CreateRowFuncVar *gtk.ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
-	xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallbackNullable(CreateRowFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))
+	var CreateRowFuncVarRef uintptr
+	if CreateRowFuncVar != nil {
+		CreateRowFuncVarPtr := uintptr(unsafe.Pointer(CreateRowFuncVar))
+		if cbRefPtr, ok := glib.GetCallback(CreateRowFuncVarPtr); ok {
+			CreateRowFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
+				cbFn := *CreateRowFuncVar
+				return cbFn(arg0, arg1)
+			}
+			CreateRowFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CreateRowFuncVarPtr, CreateRowFuncVarRef)
+		}
+	}
+	var UserDataFreeFuncVarRef uintptr
+	if UserDataFreeFuncVar != nil {
+		UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
+		if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
+			UserDataFreeFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeFuncVar
+				cbFn(arg0)
+			}
+			UserDataFreeFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
+		}
+	}
+	xPreferencesGroupBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateRowFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
 }
 }
-var xPreferencesGroupSetDescription func(uintptr, string)
+var xPreferencesGroupSetDescription func(uintptr, uintptr)
 // Sets the description for @self.
-func (x *PreferencesGroup) SetDescription(DescriptionVar string) {
+func (x *PreferencesGroup) SetDescription(DescriptionVar *string) {
-	xPreferencesGroupSetDescription(x.GoPointer(), DescriptionVar)
+	xPreferencesGroupSetDescription(x.GoPointer(), core.NullableStringToPtr(DescriptionVar))
 }
 func (x *PreferencesGroup) SetPropertyDescription(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("description", &v)
 }
 func (x *PreferencesGroup) SetPropertyTitle(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("title", &v)
 }

M v4/adw/adw-preferences-page.go +10 -10


@@ -234,21 +234,21 @@ func (x *PreferencesPage) SetDescriptionCentered(CenteredVar bool) {
234			234
235		}	235		}
236			236
237	-	var xPreferencesPageSetIconName func(uintptr, string)	237	+	var xPreferencesPageSetIconName func(uintptr, uintptr)
238			238
239		// Sets the icon name for @self.	239		// Sets the icon name for @self.
240	-	func (x *PreferencesPage) SetIconName(IconNameVar string) {	240	+	func (x PreferencesPage) SetIconName(IconNameVar string) {
241			241
242	-	xPreferencesPageSetIconName(x.GoPointer(), IconNameVar)	242	+	xPreferencesPageSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
243			243
244		}	244		}
245			245
246	-	var xPreferencesPageSetName func(uintptr, string)	246	+	var xPreferencesPageSetName func(uintptr, uintptr)
247			247
248		// Sets the name of @self.	248		// Sets the name of @self.
249	-	func (x *PreferencesPage) SetName(NameVar string) {	249	+	func (x PreferencesPage) SetName(NameVar string) {
250			250
251	-	xPreferencesPageSetName(x.GoPointer(), NameVar)	251	+	xPreferencesPageSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
252			252
253		}	253		}
254			254

@@ -286,7 +286,7 @@ func (c *PreferencesPage) SetGoPointer(ptr uintptr) {
286		func (x *PreferencesPage) SetPropertyDescription(value string) {	286		func (x *PreferencesPage) SetPropertyDescription(value string) {
287		var v gobject.Value	287		var v gobject.Value
288		v.Init(gobject.TypeStringVal)	288		v.Init(gobject.TypeStringVal)
289	-	v.SetString(value)	289	+	v.SetString(&value)
290		x.SetProperty("description", &v)	290		x.SetProperty("description", &v)
291		}	291		}
292			292

@@ -320,7 +320,7 @@ func (x *PreferencesPage) GetPropertyDescriptionCentered() bool {
320		func (x *PreferencesPage) SetPropertyIconName(value string) {	320		func (x *PreferencesPage) SetPropertyIconName(value string) {
321		var v gobject.Value	321		var v gobject.Value
322		v.Init(gobject.TypeStringVal)	322		v.Init(gobject.TypeStringVal)
323	-	v.SetString(value)	323	+	v.SetString(&value)
324		x.SetProperty("icon-name", &v)	324		x.SetProperty("icon-name", &v)
325		}	325		}
326			326

@@ -337,7 +337,7 @@ func (x *PreferencesPage) GetPropertyIconName() string {
337		func (x *PreferencesPage) SetPropertyName(value string) {	337		func (x *PreferencesPage) SetPropertyName(value string) {
338		var v gobject.Value	338		var v gobject.Value
339		v.Init(gobject.TypeStringVal)	339		v.Init(gobject.TypeStringVal)
340	-	v.SetString(value)	340	+	v.SetString(&value)
341		x.SetProperty("name", &v)	341		x.SetProperty("name", &v)
342		}	342		}
343			343

@@ -354,7 +354,7 @@ func (x *PreferencesPage) GetPropertyName() string {
354		func (x *PreferencesPage) SetPropertyTitle(value string) {	354		func (x *PreferencesPage) SetPropertyTitle(value string) {
355		var v gobject.Value	355		var v gobject.Value
356		v.Init(gobject.TypeStringVal)	356		v.Init(gobject.TypeStringVal)
357	-	v.SetString(value)	357	+	v.SetString(&value)
358		x.SetProperty("title", &v)	358		x.SetProperty("title", &v)
359		}	359		}
360			360

M v4/adw/adw-preferences-row.go +3 -3


@@ -167,7 +167,7 @@ func (c *PreferencesRow) SetGoPointer(ptr uintptr) {
167		func (x *PreferencesRow) SetPropertyTitle(value string) {	167		func (x *PreferencesRow) SetPropertyTitle(value string) {
168		var v gobject.Value	168		var v gobject.Value
169		v.Init(gobject.TypeStringVal)	169		v.Init(gobject.TypeStringVal)
170	-	v.SetString(value)	170	+	v.SetString(&value)
171		x.SetProperty("title", &v)	171		x.SetProperty("title", &v)
172		}	172		}
173			173

@@ -540,9 +540,9 @@ func (x PreferencesRow) GetActionTargetValue() glib.Variant {
540		// containing [class@ApplicationWindow] or its associated [class@Application],	540		// containing [class@ApplicationWindow] or its associated [class@Application],
541		// respectively. This is the same form used for actions in the [class@Gio.Menu]	541		// respectively. This is the same form used for actions in the [class@Gio.Menu]
542		// associated with the window.	542		// associated with the window.
543	-	func (x *PreferencesRow) SetActionName(ActionNameVar string) {	543	+	func (x PreferencesRow) SetActionName(ActionNameVar string) {
544			544
545	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	545	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
546			546
547		}	547		}
548			548

M v4/adw/adw-preferences-window.go +1 -1


@@ -322,7 +322,7 @@ func (x *PreferencesWindow) GetPropertySearchEnabled() bool {
322		func (x *PreferencesWindow) SetPropertyVisiblePageName(value string) {	322		func (x *PreferencesWindow) SetPropertyVisiblePageName(value string) {
323		var v gobject.Value	323		var v gobject.Value
324		v.Init(gobject.TypeStringVal)	324		v.Init(gobject.TypeStringVal)
325	-	v.SetString(value)	325	+	v.SetString(&value)
326		x.SetProperty("visible-page-name", &v)	326		x.SetProperty("visible-page-name", &v)
327		}	327		}
328			328

M v4/adw/adw-shortcut-label.go +2 -2


@@ -174,7 +174,7 @@ func (c *ShortcutLabel) SetGoPointer(ptr uintptr) {
174		func (x *ShortcutLabel) SetPropertyAccelerator(value string) {	174		func (x *ShortcutLabel) SetPropertyAccelerator(value string) {
175		var v gobject.Value	175		var v gobject.Value
176		v.Init(gobject.TypeStringVal)	176		v.Init(gobject.TypeStringVal)
177	-	v.SetString(value)	177	+	v.SetString(&value)
178		x.SetProperty("accelerator", &v)	178		x.SetProperty("accelerator", &v)
179		}	179		}
180			180

@@ -191,7 +191,7 @@ func (x *ShortcutLabel) GetPropertyAccelerator() string {
191		func (x *ShortcutLabel) SetPropertyDisabledText(value string) {	191		func (x *ShortcutLabel) SetPropertyDisabledText(value string) {
192		var v gobject.Value	192		var v gobject.Value
193		v.Init(gobject.TypeStringVal)	193		v.Init(gobject.TypeStringVal)
194	-	v.SetString(value)	194	+	v.SetString(&value)
195		x.SetProperty("disabled-text", &v)	195		x.SetProperty("disabled-text", &v)
196		}	196		}
197			197

M v4/adw/adw-shortcuts-item.go +4 -4


@@ -199,7 +199,7 @@ func (c *ShortcutsItem) SetGoPointer(ptr uintptr) {
199		func (x *ShortcutsItem) SetPropertyAccelerator(value string) {	199		func (x *ShortcutsItem) SetPropertyAccelerator(value string) {
200		var v gobject.Value	200		var v gobject.Value
201		v.Init(gobject.TypeStringVal)	201		v.Init(gobject.TypeStringVal)
202	-	v.SetString(value)	202	+	v.SetString(&value)
203		x.SetProperty("accelerator", &v)	203		x.SetProperty("accelerator", &v)
204		}	204		}
205			205

@@ -218,7 +218,7 @@ func (x *ShortcutsItem) GetPropertyAccelerator() string {
218		func (x *ShortcutsItem) SetPropertyActionName(value string) {	218		func (x *ShortcutsItem) SetPropertyActionName(value string) {
219		var v gobject.Value	219		var v gobject.Value
220		v.Init(gobject.TypeStringVal)	220		v.Init(gobject.TypeStringVal)
221	-	v.SetString(value)	221	+	v.SetString(&value)
222		x.SetProperty("action-name", &v)	222		x.SetProperty("action-name", &v)
223		}	223		}
224			224

@@ -235,7 +235,7 @@ func (x *ShortcutsItem) GetPropertyActionName() string {
235		func (x *ShortcutsItem) SetPropertySubtitle(value string) {	235		func (x *ShortcutsItem) SetPropertySubtitle(value string) {
236		var v gobject.Value	236		var v gobject.Value
237		v.Init(gobject.TypeStringVal)	237		v.Init(gobject.TypeStringVal)
238	-	v.SetString(value)	238	+	v.SetString(&value)
239		x.SetProperty("subtitle", &v)	239		x.SetProperty("subtitle", &v)
240		}	240		}
241			241

@@ -252,7 +252,7 @@ func (x *ShortcutsItem) GetPropertySubtitle() string {
252		func (x *ShortcutsItem) SetPropertyTitle(value string) {	252		func (x *ShortcutsItem) SetPropertyTitle(value string) {
253		var v gobject.Value	253		var v gobject.Value
254		v.Init(gobject.TypeStringVal)	254		v.Init(gobject.TypeStringVal)
255	-	v.SetString(value)	255	+	v.SetString(&value)
256		x.SetProperty("title", &v)	256		x.SetProperty("title", &v)
257		}	257		}
258			258

M v4/adw/adw-shortcuts-section.go +7 -7


@@ -50,13 +50,13 @@ func ShortcutsSectionNewFromInternalPtr(ptr uintptr) *ShortcutsSection {
50		return cls	50		return cls
51		}	51		}
52			52
53	-	var xNewShortcutsSection func(string) uintptr	53	+	var xNewShortcutsSection func(uintptr) uintptr
54			54
55		// Creates a new `AdwShortcutsSection` with @title as its title if provided.	55		// Creates a new `AdwShortcutsSection` with @title as its title if provided.
56	-	func NewShortcutsSection(TitleVar string) *ShortcutsSection {	56	+	func NewShortcutsSection(TitleVar string) ShortcutsSection {
57		var cls *ShortcutsSection	57		var cls *ShortcutsSection
58			58
59	-	cret := xNewShortcutsSection(TitleVar)	59	+	cret := xNewShortcutsSection(core.NullableStringToPtr(TitleVar))
60			60
61		if cret == 0 {	61		if cret == 0 {
62		return nil	62		return nil

@@ -84,12 +84,12 @@ func (x *ShortcutsSection) GetTitle() string {
84		return cret	84		return cret
85		}	85		}
86			86
87	-	var xShortcutsSectionSetTitle func(uintptr, string)	87	+	var xShortcutsSectionSetTitle func(uintptr, uintptr)
88			88
89		// Sets the title of @self.	89		// Sets the title of @self.
90	-	func (x *ShortcutsSection) SetTitle(TitleVar string) {	90	+	func (x ShortcutsSection) SetTitle(TitleVar string) {
91			91
92	-	xShortcutsSectionSetTitle(x.GoPointer(), TitleVar)	92	+	xShortcutsSectionSetTitle(x.GoPointer(), core.NullableStringToPtr(TitleVar))
93			93
94		}	94		}
95			95

@@ -109,7 +109,7 @@ func (c *ShortcutsSection) SetGoPointer(ptr uintptr) {
109		func (x *ShortcutsSection) SetPropertyTitle(value string) {	109		func (x *ShortcutsSection) SetPropertyTitle(value string) {
110		var v gobject.Value	110		var v gobject.Value
111		v.Init(gobject.TypeStringVal)	111		v.Init(gobject.TypeStringVal)
112	-	v.SetString(value)	112	+	v.SetString(&value)
113		x.SetProperty("title", &v)	113		x.SetProperty("title", &v)
114		}	114		}
115			115

M v4/adw/adw-spin-row.go +2 -2


@@ -789,9 +789,9 @@ func (x SpinRow) GetActionTargetValue() glib.Variant {
789		// containing [class@ApplicationWindow] or its associated [class@Application],	789		// containing [class@ApplicationWindow] or its associated [class@Application],
790		// respectively. This is the same form used for actions in the [class@Gio.Menu]	790		// respectively. This is the same form used for actions in the [class@Gio.Menu]
791		// associated with the window.	791		// associated with the window.
792	-	func (x *SpinRow) SetActionName(ActionNameVar string) {	792	+	func (x SpinRow) SetActionName(ActionNameVar string) {
793			793
794	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	794	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
795			795
796		}	796		}
797			797

M v4/adw/adw-split-button.go +5 -5


@@ -396,7 +396,7 @@ func (x *SplitButton) GetPropertyCanShrink() bool {
396		func (x *SplitButton) SetPropertyDropdownTooltip(value string) {	396		func (x *SplitButton) SetPropertyDropdownTooltip(value string) {
397		var v gobject.Value	397		var v gobject.Value
398		v.Init(gobject.TypeStringVal)	398		v.Init(gobject.TypeStringVal)
399	-	v.SetString(value)	399	+	v.SetString(&value)
400		x.SetProperty("dropdown-tooltip", &v)	400		x.SetProperty("dropdown-tooltip", &v)
401		}	401		}
402			402

@@ -418,7 +418,7 @@ func (x *SplitButton) GetPropertyDropdownTooltip() string {
418		func (x *SplitButton) SetPropertyIconName(value string) {	418		func (x *SplitButton) SetPropertyIconName(value string) {
419		var v gobject.Value	419		var v gobject.Value
420		v.Init(gobject.TypeStringVal)	420		v.Init(gobject.TypeStringVal)
421	-	v.SetString(value)	421	+	v.SetString(&value)
422		x.SetProperty("icon-name", &v)	422		x.SetProperty("icon-name", &v)
423		}	423		}
424			424

@@ -441,7 +441,7 @@ func (x *SplitButton) GetPropertyIconName() string {
441		func (x *SplitButton) SetPropertyLabel(value string) {	441		func (x *SplitButton) SetPropertyLabel(value string) {
442		var v gobject.Value	442		var v gobject.Value
443		v.Init(gobject.TypeStringVal)	443		v.Init(gobject.TypeStringVal)
444	-	v.SetString(value)	444	+	v.SetString(&value)
445		x.SetProperty("label", &v)	445		x.SetProperty("label", &v)
446		}	446		}
447			447

@@ -815,9 +815,9 @@ func (x SplitButton) GetActionTargetValue() glib.Variant {
815		// containing [class@ApplicationWindow] or its associated [class@Application],	815		// containing [class@ApplicationWindow] or its associated [class@Application],
816		// respectively. This is the same form used for actions in the [class@Gio.Menu]	816		// respectively. This is the same form used for actions in the [class@Gio.Menu]
817		// associated with the window.	817		// associated with the window.
818	-	func (x *SplitButton) SetActionName(ActionNameVar string) {	818	+	func (x SplitButton) SetActionName(ActionNameVar string) {
819			819
820	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	820	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
821			821
822		}	822		}
823			823

M v4/adw/adw-status-page.go +9 -9


@@ -159,25 +159,25 @@ func (x StatusPage) SetChild(ChildVar gtk.Widget) {
159			159
160		}	160		}
161			161
162	-	var xStatusPageSetDescription func(uintptr, string)	162	+	var xStatusPageSetDescription func(uintptr, uintptr)
163			163
164		// Sets the description markup for @self.	164		// Sets the description markup for @self.
165		//	165		//
166		// The description is displayed below the title. It is parsed as Pango markup.	166		// The description is displayed below the title. It is parsed as Pango markup.
167	-	func (x *StatusPage) SetDescription(DescriptionVar string) {	167	+	func (x StatusPage) SetDescription(DescriptionVar string) {
168			168
169	-	xStatusPageSetDescription(x.GoPointer(), DescriptionVar)	169	+	xStatusPageSetDescription(x.GoPointer(), core.NullableStringToPtr(DescriptionVar))
170			170
171		}	171		}
172			172
173	-	var xStatusPageSetIconName func(uintptr, string)	173	+	var xStatusPageSetIconName func(uintptr, uintptr)
174			174
175		// Sets the icon name for @self.	175		// Sets the icon name for @self.
176		//	176		//
177		// Changing this will set [property@StatusPage:paintable] to `NULL`.	177		// Changing this will set [property@StatusPage:paintable] to `NULL`.
178	-	func (x *StatusPage) SetIconName(IconNameVar string) {	178	+	func (x StatusPage) SetIconName(IconNameVar string) {
179			179
180	-	xStatusPageSetIconName(x.GoPointer(), IconNameVar)	180	+	xStatusPageSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
181			181
182		}	182		}
183			183

@@ -219,7 +219,7 @@ func (c *StatusPage) SetGoPointer(ptr uintptr) {
219		func (x *StatusPage) SetPropertyDescription(value string) {	219		func (x *StatusPage) SetPropertyDescription(value string) {
220		var v gobject.Value	220		var v gobject.Value
221		v.Init(gobject.TypeStringVal)	221		v.Init(gobject.TypeStringVal)
222	-	v.SetString(value)	222	+	v.SetString(&value)
223		x.SetProperty("description", &v)	223		x.SetProperty("description", &v)
224		}	224		}
225			225

@@ -238,7 +238,7 @@ func (x *StatusPage) GetPropertyDescription() string {
238		func (x *StatusPage) SetPropertyIconName(value string) {	238		func (x *StatusPage) SetPropertyIconName(value string) {
239		var v gobject.Value	239		var v gobject.Value
240		v.Init(gobject.TypeStringVal)	240		v.Init(gobject.TypeStringVal)
241	-	v.SetString(value)	241	+	v.SetString(&value)
242		x.SetProperty("icon-name", &v)	242		x.SetProperty("icon-name", &v)
243		}	243		}
244			244

@@ -259,7 +259,7 @@ func (x *StatusPage) GetPropertyIconName() string {
259		func (x *StatusPage) SetPropertyTitle(value string) {	259		func (x *StatusPage) SetPropertyTitle(value string) {
260		var v gobject.Value	260		var v gobject.Value
261		v.Init(gobject.TypeStringVal)	261		v.Init(gobject.TypeStringVal)
262	-	v.SetString(value)	262	+	v.SetString(&value)
263		x.SetProperty("title", &v)	263		x.SetProperty("title", &v)
264		}	264		}
265			265

M v4/adw/adw-switch-row.go +2 -2


@@ -431,9 +431,9 @@ func (x SwitchRow) GetActionTargetValue() glib.Variant {
431		// containing [class@ApplicationWindow] or its associated [class@Application],	431		// containing [class@ApplicationWindow] or its associated [class@Application],
432		// respectively. This is the same form used for actions in the [class@Gio.Menu]	432		// respectively. This is the same form used for actions in the [class@Gio.Menu]
433		// associated with the window.	433		// associated with the window.
434	-	func (x *SwitchRow) SetActionName(ActionNameVar string) {	434	+	func (x SwitchRow) SetActionName(ActionNameVar string) {
435			435
436	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	436	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
437			437
438		}	438		}
439			439

M v4/adw/adw-tab-button.go +2 -2


@@ -463,9 +463,9 @@ func (x TabButton) GetActionTargetValue() glib.Variant {
463		// containing [class@ApplicationWindow] or its associated [class@Application],	463		// containing [class@ApplicationWindow] or its associated [class@Application],
464		// respectively. This is the same form used for actions in the [class@Gio.Menu]	464		// respectively. This is the same form used for actions in the [class@Gio.Menu]
465		// associated with the window.	465		// associated with the window.
466	-	func (x *TabButton) SetActionName(ActionNameVar string) {	466	+	func (x TabButton) SetActionName(ActionNameVar string) {
467			467
468	-	gtk.XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	468	+	gtk.XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
469			469
470		}	470		}
471			471

M v4/adw/adw-tab-view.go +4 -4


@@ -544,7 +544,7 @@ func (x *TabPage) GetPropertyIndicatorActivatable() bool {
544		func (x *TabPage) SetPropertyIndicatorTooltip(value string) {	544		func (x *TabPage) SetPropertyIndicatorTooltip(value string) {
545		var v gobject.Value	545		var v gobject.Value
546		v.Init(gobject.TypeStringVal)	546		v.Init(gobject.TypeStringVal)
547	-	v.SetString(value)	547	+	v.SetString(&value)
548		x.SetProperty("indicator-tooltip", &v)	548		x.SetProperty("indicator-tooltip", &v)
549		}	549		}
550			550

@@ -570,7 +570,7 @@ func (x *TabPage) GetPropertyIndicatorTooltip() string {
570		func (x *TabPage) SetPropertyKeyword(value string) {	570		func (x *TabPage) SetPropertyKeyword(value string) {
571		var v gobject.Value	571		var v gobject.Value
572		v.Init(gobject.TypeStringVal)	572		v.Init(gobject.TypeStringVal)
573	-	v.SetString(value)	573	+	v.SetString(&value)
574		x.SetProperty("keyword", &v)	574		x.SetProperty("keyword", &v)
575		}	575		}
576			576

@@ -786,7 +786,7 @@ func (x *TabPage) GetPropertyThumbnailYalign() float32 {
786		func (x *TabPage) SetPropertyTitle(value string) {	786		func (x *TabPage) SetPropertyTitle(value string) {
787		var v gobject.Value	787		var v gobject.Value
788		v.Init(gobject.TypeStringVal)	788		v.Init(gobject.TypeStringVal)
789	-	v.SetString(value)	789	+	v.SetString(&value)
790		x.SetProperty("title", &v)	790		x.SetProperty("title", &v)
791		}	791		}
792			792

@@ -815,7 +815,7 @@ func (x *TabPage) GetPropertyTitle() string {
815		func (x *TabPage) SetPropertyTooltip(value string) {	815		func (x *TabPage) SetPropertyTooltip(value string) {
816		var v gobject.Value	816		var v gobject.Value
817		v.Init(gobject.TypeStringVal)	817		v.Init(gobject.TypeStringVal)
818	-	v.SetString(value)	818	+	v.SetString(&value)
819		x.SetProperty("tooltip", &v)	819		x.SetProperty("tooltip", &v)
820		}	820		}
821			821

M v4/adw/adw-toast.go +15 -15


@@ -327,20 +327,20 @@ func (x *Toast) GetUseMarkup() bool {
327		return cret	327		return cret
328		}	328		}
329			329
330	-	var xToastSetActionName func(uintptr, string)	330	+	var xToastSetActionName func(uintptr, uintptr)
331			331
332		// Sets the name of the associated action.	332		// Sets the name of the associated action.
333		//	333		//
334		// It will be activated when clicking the button.	334		// It will be activated when clicking the button.
335		//	335		//
336		// See [property@Toast:action-target].	336		// See [property@Toast:action-target].
337	-	func (x *Toast) SetActionName(ActionNameVar string) {	337	+	func (x Toast) SetActionName(ActionNameVar string) {
338			338
339	-	xToastSetActionName(x.GoPointer(), ActionNameVar)	339	+	xToastSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
340			340
341		}	341		}
342			342
343	-	var xToastSetActionTarget func(uintptr, string, ...interface{})	343	+	var xToastSetActionTarget func(uintptr, uintptr, ...interface{})
344			344
345		// Sets the parameter for action invocations.	345		// Sets the parameter for action invocations.
346		//	346		//

@@ -351,9 +351,9 @@ var xToastSetActionTarget func(uintptr, string, ...interface{})
351		// If you are setting a string-valued target and want to set	351		// If you are setting a string-valued target and want to set
352		// the action name at the same time, you can use	352		// the action name at the same time, you can use
353		// [method@Toast.set_detailed_action_name].	353		// [method@Toast.set_detailed_action_name].
354	-	func (x *Toast) SetActionTarget(FormatStringVar string, varArgs ...interface{}) {	354	+	func (x Toast) SetActionTarget(FormatStringVar string, varArgs ...interface{}) {
355			355
356	-	xToastSetActionTarget(x.GoPointer(), FormatStringVar, varArgs...)	356	+	xToastSetActionTarget(x.GoPointer(), core.NullableStringToPtr(FormatStringVar), varArgs...)
357			357
358		}	358		}
359			359

@@ -369,7 +369,7 @@ func (x Toast) SetActionTargetValue(ActionTargetVar glib.Variant) {
369			369
370		}	370		}
371			371
372	-	var xToastSetButtonLabel func(uintptr, string)	372	+	var xToastSetButtonLabel func(uintptr, uintptr)
373			373
374		// Sets the label to show on the button.	374		// Sets the label to show on the button.
375		//	375		//

@@ -378,9 +378,9 @@ var xToastSetButtonLabel func(uintptr, string)
378		// If set to `NULL`, the button won't be shown.	378		// If set to `NULL`, the button won't be shown.
379		//	379		//
380		// See [property@Toast:action-name].	380		// See [property@Toast:action-name].
381	-	func (x *Toast) SetButtonLabel(ButtonLabelVar string) {	381	+	func (x Toast) SetButtonLabel(ButtonLabelVar string) {
382			382
383	-	xToastSetButtonLabel(x.GoPointer(), ButtonLabelVar)	383	+	xToastSetButtonLabel(x.GoPointer(), core.NullableStringToPtr(ButtonLabelVar))
384			384
385		}	385		}
386			386

@@ -398,15 +398,15 @@ func (x Toast) SetCustomTitle(WidgetVar gtk.Widget) {
398			398
399		}	399		}
400			400
401	-	var xToastSetDetailedActionName func(uintptr, string)	401	+	var xToastSetDetailedActionName func(uintptr, uintptr)
402			402
403		// Sets the action name and its parameter.	403		// Sets the action name and its parameter.
404		//	404		//
405		// @detailed_action_name is a string in the format accepted by	405		// @detailed_action_name is a string in the format accepted by
406		// [func@Gio.Action.parse_detailed_name].	406		// [func@Gio.Action.parse_detailed_name].
407	-	func (x *Toast) SetDetailedActionName(DetailedActionNameVar string) {	407	+	func (x Toast) SetDetailedActionName(DetailedActionNameVar string) {
408			408
409	-	xToastSetDetailedActionName(x.GoPointer(), DetailedActionNameVar)	409	+	xToastSetDetailedActionName(x.GoPointer(), core.NullableStringToPtr(DetailedActionNameVar))
410			410
411		}	411		}
412			412

@@ -488,7 +488,7 @@ func (c *Toast) SetGoPointer(ptr uintptr) {
488		func (x *Toast) SetPropertyActionName(value string) {	488		func (x *Toast) SetPropertyActionName(value string) {
489		var v gobject.Value	489		var v gobject.Value
490		v.Init(gobject.TypeStringVal)	490		v.Init(gobject.TypeStringVal)
491	-	v.SetString(value)	491	+	v.SetString(&value)
492		x.SetProperty("action-name", &v)	492		x.SetProperty("action-name", &v)
493		}	493		}
494			494

@@ -532,7 +532,7 @@ func (x *Toast) GetPropertyActionTarget() uintptr {
532		func (x *Toast) SetPropertyButtonLabel(value string) {	532		func (x *Toast) SetPropertyButtonLabel(value string) {
533		var v gobject.Value	533		var v gobject.Value
534		v.Init(gobject.TypeStringVal)	534		v.Init(gobject.TypeStringVal)
535	-	v.SetString(value)	535	+	v.SetString(&value)
536		x.SetProperty("button-label", &v)	536		x.SetProperty("button-label", &v)
537		}	537		}
538			538

@@ -590,7 +590,7 @@ func (x *Toast) GetPropertyTimeout() uint {
590		func (x *Toast) SetPropertyTitle(value string) {	590		func (x *Toast) SetPropertyTitle(value string) {
591		var v gobject.Value	591		var v gobject.Value
592		v.Init(gobject.TypeStringVal)	592		v.Init(gobject.TypeStringVal)
593	-	v.SetString(value)	593	+	v.SetString(&value)
594		x.SetProperty("title", &v)	594		x.SetProperty("title", &v)
595		}	595		}
596			596

M v4/adw/adw-toggle-group.go +17 -17


@@ -172,41 +172,41 @@ func (x *Toggle) SetEnabled(EnabledVar bool) {
172			172
173		}	173		}
174			174
175	-	var xToggleSetIconName func(uintptr, string)	175	+	var xToggleSetIconName func(uintptr, uintptr)
176			176
177		// Sets the icon name of @self to @icon_name.	177		// Sets the icon name of @self to @icon_name.
178		//	178		//
179		// The icon will be displayed alone or next to the label, unless	179		// The icon will be displayed alone or next to the label, unless
180		// [property@Toggle:child] is set.	180		// [property@Toggle:child] is set.
181	-	func (x *Toggle) SetIconName(IconNameVar string) {	181	+	func (x Toggle) SetIconName(IconNameVar string) {
182			182
183	-	xToggleSetIconName(x.GoPointer(), IconNameVar)	183	+	xToggleSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
184			184
185		}	185		}
186			186
187	-	var xToggleSetLabel func(uintptr, string)	187	+	var xToggleSetLabel func(uintptr, uintptr)
188			188
189		// Sets the label of @self to @label.	189		// Sets the label of @self to @label.
190		//	190		//
191		// The label will be displayed alone or next to the icon, unless	191		// The label will be displayed alone or next to the icon, unless
192		// [property@Toggle:child] is set, but will still be read out by the screen	192		// [property@Toggle:child] is set, but will still be read out by the screen
193		// reader.	193		// reader.
194	-	func (x *Toggle) SetLabel(LabelVar string) {	194	+	func (x Toggle) SetLabel(LabelVar string) {
195			195
196	-	xToggleSetLabel(x.GoPointer(), LabelVar)	196	+	xToggleSetLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
197			197
198		}	198		}
199			199
200	-	var xToggleSetName func(uintptr, string)	200	+	var xToggleSetName func(uintptr, uintptr)
201			201
202		// Sets the name of @self to @name.	202		// Sets the name of @self to @name.
203		//	203		//
204		// Allows accessing @self by its name instead of index.	204		// Allows accessing @self by its name instead of index.
205		//	205		//
206		// See [property@ToggleGroup:active-name].	206		// See [property@ToggleGroup:active-name].
207	-	func (x *Toggle) SetName(NameVar string) {	207	+	func (x Toggle) SetName(NameVar string) {
208			208
209	-	xToggleSetName(x.GoPointer(), NameVar)	209	+	xToggleSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
210			210
211		}	211		}
212			212

@@ -268,7 +268,7 @@ func (x *Toggle) GetPropertyEnabled() bool {
268		func (x *Toggle) SetPropertyIconName(value string) {	268		func (x *Toggle) SetPropertyIconName(value string) {
269		var v gobject.Value	269		var v gobject.Value
270		v.Init(gobject.TypeStringVal)	270		v.Init(gobject.TypeStringVal)
271	-	v.SetString(value)	271	+	v.SetString(&value)
272		x.SetProperty("icon-name", &v)	272		x.SetProperty("icon-name", &v)
273		}	273		}
274			274

@@ -292,7 +292,7 @@ func (x *Toggle) GetPropertyIconName() string {
292		func (x *Toggle) SetPropertyLabel(value string) {	292		func (x *Toggle) SetPropertyLabel(value string) {
293		var v gobject.Value	293		var v gobject.Value
294		v.Init(gobject.TypeStringVal)	294		v.Init(gobject.TypeStringVal)
295	-	v.SetString(value)	295	+	v.SetString(&value)
296		x.SetProperty("label", &v)	296		x.SetProperty("label", &v)
297		}	297		}
298			298

@@ -317,7 +317,7 @@ func (x *Toggle) GetPropertyLabel() string {
317		func (x *Toggle) SetPropertyName(value string) {	317		func (x *Toggle) SetPropertyName(value string) {
318		var v gobject.Value	318		var v gobject.Value
319		v.Init(gobject.TypeStringVal)	319		v.Init(gobject.TypeStringVal)
320	-	v.SetString(value)	320	+	v.SetString(&value)
321		x.SetProperty("name", &v)	321		x.SetProperty("name", &v)
322		}	322		}
323			323

@@ -340,7 +340,7 @@ func (x *Toggle) GetPropertyName() string {
340		func (x *Toggle) SetPropertyTooltip(value string) {	340		func (x *Toggle) SetPropertyTooltip(value string) {
341		var v gobject.Value	341		var v gobject.Value
342		v.Init(gobject.TypeStringVal)	342		v.Init(gobject.TypeStringVal)
343	-	v.SetString(value)	343	+	v.SetString(&value)
344		x.SetProperty("tooltip", &v)	344		x.SetProperty("tooltip", &v)
345		}	345		}
346			346

@@ -659,16 +659,16 @@ func (x *ToggleGroup) SetActive(ActiveVar uint) {
659			659
660		}	660		}
661			661
662	-	var xToggleGroupSetActiveName func(uintptr, string)	662	+	var xToggleGroupSetActiveName func(uintptr, uintptr)
663			663
664		// Sets the active toggle for @self.	664		// Sets the active toggle for @self.
665		//	665		//
666		// The name can be set via [property@Toggle:name].	666		// The name can be set via [property@Toggle:name].
667		//	667		//
668		// If @name is `NULL`, unset the current active toggle instead.	668		// If @name is `NULL`, unset the current active toggle instead.
669	-	func (x *ToggleGroup) SetActiveName(NameVar string) {	669	+	func (x ToggleGroup) SetActiveName(NameVar string) {
670			670
671	-	xToggleGroupSetActiveName(x.GoPointer(), NameVar)	671	+	xToggleGroupSetActiveName(x.GoPointer(), core.NullableStringToPtr(NameVar))
672			672
673		}	673		}
674			674

@@ -745,7 +745,7 @@ func (x *ToggleGroup) GetPropertyActive() uint {
745		func (x *ToggleGroup) SetPropertyActiveName(value string) {	745		func (x *ToggleGroup) SetPropertyActiveName(value string) {
746		var v gobject.Value	746		var v gobject.Value
747		v.Init(gobject.TypeStringVal)	747		v.Init(gobject.TypeStringVal)
748	-	v.SetString(value)	748	+	v.SetString(&value)
749		x.SetProperty("active-name", &v)	749		x.SetProperty("active-name", &v)
750		}	750		}
751			751

M v4/adw/adw-view-stack.go +22 -22


@@ -151,15 +151,15 @@ func (x ViewStack) Add(ChildVar gtk.Widget) *ViewStackPage {
151		return cls	151		return cls
152		}	152		}
153			153
154	-	var xViewStackAddNamed func(uintptr, uintptr, string) uintptr	154	+	var xViewStackAddNamed func(uintptr, uintptr, uintptr) uintptr
155			155
156		// Adds a child to @self.	156		// Adds a child to @self.
157		//	157		//
158		// The child is identified by the @name.	158		// The child is identified by the @name.
159	-	func (x ViewStack) AddNamed(ChildVar gtk.Widget, NameVar string) *ViewStackPage {	159	+	func (x ViewStack) AddNamed(ChildVar gtk.Widget, NameVar string) ViewStackPage {
160		var cls *ViewStackPage	160		var cls *ViewStackPage
161			161
162	-	cret := xViewStackAddNamed(x.GoPointer(), ChildVar.GoPointer(), NameVar)	162	+	cret := xViewStackAddNamed(x.GoPointer(), ChildVar.GoPointer(), core.NullableStringToPtr(NameVar))
163			163
164		if cret == 0 {	164		if cret == 0 {
165		return nil	165		return nil

@@ -170,16 +170,16 @@ func (x ViewStack) AddNamed(ChildVar gtk.Widget, NameVar string) *ViewStackPag
170		return cls	170		return cls
171		}	171		}
172			172
173	-	var xViewStackAddTitled func(uintptr, uintptr, string, string) uintptr	173	+	var xViewStackAddTitled func(uintptr, uintptr, uintptr, string) uintptr
174			174
175		// Adds a child to @self.	175		// Adds a child to @self.
176		//	176		//
177		// The child is identified by the @name. The @title will be used by	177		// The child is identified by the @name. The @title will be used by
178		// [class@ViewSwitcher] to represent @child, so it should be short.	178		// [class@ViewSwitcher] to represent @child, so it should be short.
179	-	func (x ViewStack) AddTitled(ChildVar gtk.Widget, NameVar string, TitleVar string) *ViewStackPage {	179	+	func (x ViewStack) AddTitled(ChildVar gtk.Widget, NameVar string, TitleVar string) ViewStackPage {
180		var cls *ViewStackPage	180		var cls *ViewStackPage
181			181
182	-	cret := xViewStackAddTitled(x.GoPointer(), ChildVar.GoPointer(), NameVar, TitleVar)	182	+	cret := xViewStackAddTitled(x.GoPointer(), ChildVar.GoPointer(), core.NullableStringToPtr(NameVar), TitleVar)
183			183
184		if cret == 0 {	184		if cret == 0 {
185		return nil	185		return nil

@@ -190,16 +190,16 @@ func (x ViewStack) AddTitled(ChildVar gtk.Widget, NameVar string, TitleVar str
190		return cls	190		return cls
191		}	191		}
192			192
193	-	var xViewStackAddTitledWithIcon func(uintptr, uintptr, string, string, string) uintptr	193	+	var xViewStackAddTitledWithIcon func(uintptr, uintptr, uintptr, string, string) uintptr
194			194
195		// Adds a child to @self.	195		// Adds a child to @self.
196		//	196		//
197		// The child is identified by the @name. The @title and @icon_name will be used	197		// The child is identified by the @name. The @title and @icon_name will be used
198		// by [class@ViewSwitcher] to represent @child.	198		// by [class@ViewSwitcher] to represent @child.
199	-	func (x ViewStack) AddTitledWithIcon(ChildVar gtk.Widget, NameVar string, TitleVar string, IconNameVar string) *ViewStackPage {	199	+	func (x ViewStack) AddTitledWithIcon(ChildVar gtk.Widget, NameVar string, TitleVar string, IconNameVar string) ViewStackPage {
200		var cls *ViewStackPage	200		var cls *ViewStackPage
201			201
202	-	cret := xViewStackAddTitledWithIcon(x.GoPointer(), ChildVar.GoPointer(), NameVar, TitleVar, IconNameVar)	202	+	cret := xViewStackAddTitledWithIcon(x.GoPointer(), ChildVar.GoPointer(), core.NullableStringToPtr(NameVar), TitleVar, IconNameVar)
203			203
204		if cret == 0 {	204		if cret == 0 {
205		return nil	205		return nil

@@ -556,7 +556,7 @@ func (x *ViewStack) GetPropertyVhomogeneous() bool {
556		func (x *ViewStack) SetPropertyVisibleChildName(value string) {	556		func (x *ViewStack) SetPropertyVisibleChildName(value string) {
557		var v gobject.Value	557		var v gobject.Value
558		v.Init(gobject.TypeStringVal)	558		v.Init(gobject.TypeStringVal)
559	-	v.SetString(value)	559	+	v.SetString(&value)
560		x.SetProperty("visible-child-name", &v)	560		x.SetProperty("visible-child-name", &v)
561		}	561		}
562			562

@@ -962,21 +962,21 @@ func (x *ViewStackPage) SetBadgeNumber(BadgeNumberVar uint) {
962			962
963		}	963		}
964			964
965	-	var xViewStackPageSetIconName func(uintptr, string)	965	+	var xViewStackPageSetIconName func(uintptr, uintptr)
966			966
967		// Sets the icon name of the page.	967		// Sets the icon name of the page.
968	-	func (x *ViewStackPage) SetIconName(IconNameVar string) {	968	+	func (x ViewStackPage) SetIconName(IconNameVar string) {
969			969
970	-	xViewStackPageSetIconName(x.GoPointer(), IconNameVar)	970	+	xViewStackPageSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
971			971
972		}	972		}
973			973
974	-	var xViewStackPageSetName func(uintptr, string)	974	+	var xViewStackPageSetName func(uintptr, uintptr)
975			975
976		// Sets the name of the page.	976		// Sets the name of the page.
977	-	func (x *ViewStackPage) SetName(NameVar string) {	977	+	func (x ViewStackPage) SetName(NameVar string) {
978			978
979	-	xViewStackPageSetName(x.GoPointer(), NameVar)	979	+	xViewStackPageSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
980			980
981		}	981		}
982			982

@@ -991,12 +991,12 @@ func (x *ViewStackPage) SetNeedsAttention(NeedsAttentionVar bool) {
991			991
992		}	992		}
993			993
994	-	var xViewStackPageSetTitle func(uintptr, string)	994	+	var xViewStackPageSetTitle func(uintptr, uintptr)
995			995
996		// Sets the page title.	996		// Sets the page title.
997	-	func (x *ViewStackPage) SetTitle(TitleVar string) {	997	+	func (x ViewStackPage) SetTitle(TitleVar string) {
998			998
999	-	xViewStackPageSetTitle(x.GoPointer(), TitleVar)	999	+	xViewStackPageSetTitle(x.GoPointer(), core.NullableStringToPtr(TitleVar))
1000			1000
1001		}	1001		}
1002			1002

@@ -1064,7 +1064,7 @@ func (x *ViewStackPage) GetPropertyBadgeNumber() uint {
1064		func (x *ViewStackPage) SetPropertyIconName(value string) {	1064		func (x *ViewStackPage) SetPropertyIconName(value string) {
1065		var v gobject.Value	1065		var v gobject.Value
1066		v.Init(gobject.TypeStringVal)	1066		v.Init(gobject.TypeStringVal)
1067	-	v.SetString(value)	1067	+	v.SetString(&value)
1068		x.SetProperty("icon-name", &v)	1068		x.SetProperty("icon-name", &v)
1069		}	1069		}
1070			1070

@@ -1081,7 +1081,7 @@ func (x *ViewStackPage) GetPropertyIconName() string {
1081		func (x *ViewStackPage) SetPropertyName(value string) {	1081		func (x *ViewStackPage) SetPropertyName(value string) {
1082		var v gobject.Value	1082		var v gobject.Value
1083		v.Init(gobject.TypeStringVal)	1083		v.Init(gobject.TypeStringVal)
1084	-	v.SetString(value)	1084	+	v.SetString(&value)
1085		x.SetProperty("name", &v)	1085		x.SetProperty("name", &v)
1086		}	1086		}
1087			1087

@@ -1119,7 +1119,7 @@ func (x *ViewStackPage) GetPropertyNeedsAttention() bool {
1119		func (x *ViewStackPage) SetPropertyTitle(value string) {	1119		func (x *ViewStackPage) SetPropertyTitle(value string) {
1120		var v gobject.Value	1120		var v gobject.Value
1121		v.Init(gobject.TypeStringVal)	1121		v.Init(gobject.TypeStringVal)
1122	-	v.SetString(value)	1122	+	v.SetString(&value)
1123		x.SetProperty("title", &v)	1123		x.SetProperty("title", &v)
1124		}	1124		}
1125			1125

M v4/adw/adw-view-switcher-title.go +2 -2


@@ -240,7 +240,7 @@ func (c *ViewSwitcherTitle) SetGoPointer(ptr uintptr) {
240		func (x *ViewSwitcherTitle) SetPropertySubtitle(value string) {	240		func (x *ViewSwitcherTitle) SetPropertySubtitle(value string) {
241		var v gobject.Value	241		var v gobject.Value
242		v.Init(gobject.TypeStringVal)	242		v.Init(gobject.TypeStringVal)
243	-	v.SetString(value)	243	+	v.SetString(&value)
244		x.SetProperty("subtitle", &v)	244		x.SetProperty("subtitle", &v)
245		}	245		}
246			246

@@ -262,7 +262,7 @@ func (x *ViewSwitcherTitle) GetPropertySubtitle() string {
262		func (x *ViewSwitcherTitle) SetPropertyTitle(value string) {	262		func (x *ViewSwitcherTitle) SetPropertyTitle(value string) {
263		var v gobject.Value	263		var v gobject.Value
264		v.Init(gobject.TypeStringVal)	264		v.Init(gobject.TypeStringVal)
265	-	v.SetString(value)	265	+	v.SetString(&value)
266		x.SetProperty("title", &v)	266		x.SetProperty("title", &v)
267		}	267		}
268			268

M v4/adw/adw-window-title.go +2 -2


@@ -129,7 +129,7 @@ func (c *WindowTitle) SetGoPointer(ptr uintptr) {
129		func (x *WindowTitle) SetPropertySubtitle(value string) {	129		func (x *WindowTitle) SetPropertySubtitle(value string) {
130		var v gobject.Value	130		var v gobject.Value
131		v.Init(gobject.TypeStringVal)	131		v.Init(gobject.TypeStringVal)
132	-	v.SetString(value)	132	+	v.SetString(&value)
133		x.SetProperty("subtitle", &v)	133		x.SetProperty("subtitle", &v)
134		}	134		}
135			135

@@ -151,7 +151,7 @@ func (x *WindowTitle) GetPropertySubtitle() string {
151		func (x *WindowTitle) SetPropertyTitle(value string) {	151		func (x *WindowTitle) SetPropertyTitle(value string) {
152		var v gobject.Value	152		var v gobject.Value
153		v.Init(gobject.TypeStringVal)	153		v.Init(gobject.TypeStringVal)
154	-	v.SetString(value)	154	+	v.SetString(&value)
155		x.SetProperty("title", &v)	155		x.SetProperty("title", &v)
156		}	156		}
157			157

M v4/gdk/gdkapplaunchcontext.go +3 -3


@@ -98,7 +98,7 @@ func (x *AppLaunchContext) SetIcon(IconVar gio.Icon) {
98			98
99		}	99		}
100			100
101	-	var xAppLaunchContextSetIconName func(uintptr, string)	101	+	var xAppLaunchContextSetIconName func(uintptr, uintptr)
102			102
103		// Sets the icon for applications that are launched with this context.	103		// Sets the icon for applications that are launched with this context.
104		//	104		//

@@ -109,9 +109,9 @@ var xAppLaunchContextSetIconName func(uintptr, string)
109		// If neither @icon or @icon_name is set, the icon is taken from either	109		// If neither @icon or @icon_name is set, the icon is taken from either
110		// the file that is passed to launched application or from the `GAppInfo`	110		// the file that is passed to launched application or from the `GAppInfo`
111		// for the launched application itself.	111		// for the launched application itself.
112	-	func (x *AppLaunchContext) SetIconName(IconNameVar string) {	112	+	func (x AppLaunchContext) SetIconName(IconNameVar string) {
113			113
114	-	xAppLaunchContextSetIconName(x.GoPointer(), IconNameVar)	114	+	xAppLaunchContextSetIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
115			115
116		}	116		}
117			117

M v4/gdk/gdkclipboard.go +80 -5


@@ -114,7 +114,22 @@ var xClipboardReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
114		// to fulfill the request, preferring the ones listed first.	114		// to fulfill the request, preferring the ones listed first.
115		func (x Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	115		func (x Clipboard) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
116			116
117	-	xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	117	+	var CallbackVarRef uintptr
			118	+	if CallbackVar != nil {
			119	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			120	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			121	+	CallbackVarRef = cbRefPtr
			122	+	} else {
			123	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			124	+	cbFn := *CallbackVar
			125	+	cbFn(arg0, arg1, arg2)
			126	+	}
			127	+	CallbackVarRef = purego.NewCallback(fcb)
			128	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			129	+	}
			130	+	}
			131	+
			132	+	xClipboardReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
118			133
119		}	134		}
120			135

@@ -150,7 +165,22 @@ var xClipboardReadTextAsync func(uintptr, uintptr, uintptr, uintptr)
150		// need more control over the operation.	165		// need more control over the operation.
151		func (x Clipboard) ReadTextAsync(CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	166		func (x Clipboard) ReadTextAsync(CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
152			167
153	-	xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	168	+	var CallbackVarRef uintptr
			169	+	if CallbackVar != nil {
			170	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			171	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			172	+	CallbackVarRef = cbRefPtr
			173	+	} else {
			174	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			175	+	cbFn := *CallbackVar
			176	+	cbFn(arg0, arg1, arg2)
			177	+	}
			178	+	CallbackVarRef = purego.NewCallback(fcb)
			179	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			180	+	}
			181	+	}
			182	+
			183	+	xClipboardReadTextAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
154			184
155		}	185		}
156			186

@@ -179,7 +209,22 @@ var xClipboardReadTextureAsync func(uintptr, uintptr, uintptr, uintptr)
179		// need more control over the operation.	209		// need more control over the operation.
180		func (x Clipboard) ReadTextureAsync(CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	210		func (x Clipboard) ReadTextureAsync(CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
181			211
182	-	xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	212	+	var CallbackVarRef uintptr
			213	+	if CallbackVar != nil {
			214	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			215	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			216	+	CallbackVarRef = cbRefPtr
			217	+	} else {
			218	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			219	+	cbFn := *CallbackVar
			220	+	cbFn(arg0, arg1, arg2)
			221	+	}
			222	+	CallbackVarRef = purego.NewCallback(fcb)
			223	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			224	+	}
			225	+	}
			226	+
			227	+	xClipboardReadTextureAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
183			228
184		}	229		}
185			230

@@ -216,7 +261,22 @@ var xClipboardReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, u
216		// [func@content_deserialize_async] to convert the clipboard's data.	261		// [func@content_deserialize_async] to convert the clipboard's data.
217		func (x Clipboard) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	262		func (x Clipboard) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
218			263
219	-	xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	264	+	var CallbackVarRef uintptr
			265	+	if CallbackVar != nil {
			266	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			267	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			268	+	CallbackVarRef = cbRefPtr
			269	+	} else {
			270	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			271	+	cbFn := *CallbackVar
			272	+	cbFn(arg0, arg1, arg2)
			273	+	}
			274	+	CallbackVarRef = purego.NewCallback(fcb)
			275	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			276	+	}
			277	+	}
			278	+
			279	+	xClipboardReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
220			280
221		}	281		}
222			282

@@ -327,7 +387,22 @@ var xClipboardStoreAsync func(uintptr, int, uintptr, uintptr, uintptr)
327		// is shut down, so you likely don't need to call it.	387		// is shut down, so you likely don't need to call it.
328		func (x Clipboard) StoreAsync(IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	388		func (x Clipboard) StoreAsync(IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
329			389
330	-	xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	390	+	var CallbackVarRef uintptr
			391	+	if CallbackVar != nil {
			392	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			393	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			394	+	CallbackVarRef = cbRefPtr
			395	+	} else {
			396	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			397	+	cbFn := *CallbackVar
			398	+	cbFn(arg0, arg1, arg2)
			399	+	}
			400	+	CallbackVarRef = purego.NewCallback(fcb)
			401	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			402	+	}
			403	+	}
			404	+
			405	+	xClipboardStoreAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
331			406
332		}	407		}
333			408

M v4/gdk/gdkcontentdeserializer.go +65 -3


@@ -2,6 +2,8 @@
2		package gdk	2		package gdk
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/gio"	9		"github.com/jwijenbergh/puregotk/v4/gio"

@@ -25,7 +27,22 @@ var xContentDeserializeAsync func(uintptr, string, types.GType, int, uintptr, ui
25		// indicate a higher priority.	27		// indicate a higher priority.
26		func ContentDeserializeAsync(StreamVar gio.InputStream, MimeTypeVar string, TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	28		func ContentDeserializeAsync(StreamVar gio.InputStream, MimeTypeVar string, TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
27			29
28	-	xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	30	+	var CallbackVarRef uintptr
			31	+	if CallbackVar != nil {
			32	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			33	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			34	+	CallbackVarRef = cbRefPtr
			35	+	} else {
			36	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			37	+	cbFn := *CallbackVar
			38	+	cbFn(arg0, arg1, arg2)
			39	+	}
			40	+	CallbackVarRef = purego.NewCallback(fcb)
			41	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			42	+	}
			43	+	}
			44	+
			45	+	xContentDeserializeAsync(StreamVar.GoPointer(), MimeTypeVar, TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
29			46
30		}	47		}
31			48

@@ -52,7 +69,37 @@ var xContentRegisterDeserializer func(string, types.GType, uintptr, uintptr, uin
52		// so applications can override the built-in deserializers.	69		// so applications can override the built-in deserializers.
53		func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar ContentDeserializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {	70		func ContentRegisterDeserializer(MimeTypeVar string, TypeVar types.GType, DeserializeVar ContentDeserializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
54			71
55	-	xContentRegisterDeserializer(MimeTypeVar, TypeVar, glib.NewCallback(DeserializeVar), DataVar, glib.NewCallback(NotifyVar))	72	+	var DeserializeVarRef uintptr
			73	+	if DeserializeVar != nil {
			74	+	DeserializeVarPtr := uintptr(unsafe.Pointer(DeserializeVar))
			75	+	if cbRefPtr, ok := glib.GetCallback(DeserializeVarPtr); ok {
			76	+	DeserializeVarRef = cbRefPtr
			77	+	} else {
			78	+	fcb := func(arg0 uintptr) {
			79	+	cbFn := *DeserializeVar
			80	+	cbFn(arg0)
			81	+	}
			82	+	DeserializeVarRef = purego.NewCallback(fcb)
			83	+	glib.SaveCallback(DeserializeVarPtr, DeserializeVarRef)
			84	+	}
			85	+	}
			86	+
			87	+	var NotifyVarRef uintptr
			88	+	if NotifyVar != nil {
			89	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			90	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			91	+	NotifyVarRef = cbRefPtr
			92	+	} else {
			93	+	fcb := func(arg0 uintptr) {
			94	+	cbFn := *NotifyVar
			95	+	cbFn(arg0)
			96	+	}
			97	+	NotifyVarRef = purego.NewCallback(fcb)
			98	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			99	+	}
			100	+	}
			101	+
			102	+	xContentRegisterDeserializer(MimeTypeVar, TypeVar, DeserializeVarRef, DataVar, NotifyVarRef)
56			103
57		}	104		}
58			105

@@ -203,7 +250,22 @@ var xContentDeserializerSetTaskData func(uintptr, uintptr, uintptr)
203		// Associate data with the current deserialization operation.	250		// Associate data with the current deserialization operation.
204		func (x ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {	251		func (x ContentDeserializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
205			252
206	-	xContentDeserializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))	253	+	var NotifyVarRef uintptr
			254	+	if NotifyVar != nil {
			255	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			256	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			257	+	NotifyVarRef = cbRefPtr
			258	+	} else {
			259	+	fcb := func(arg0 uintptr) {
			260	+	cbFn := *NotifyVar
			261	+	cbFn(arg0)
			262	+	}
			263	+	NotifyVarRef = purego.NewCallback(fcb)
			264	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			265	+	}
			266	+	}
			267	+
			268	+	xContentDeserializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)
207			269
208		}	270		}
209			271

M v4/gdk/gdkcontentprovider.go +16 -1


@@ -402,7 +402,22 @@ var xContentProviderWriteMimeTypeAsync func(uintptr, string, uintptr, int, uintp
402		// The given @stream will not be closed.	402		// The given @stream will not be closed.
403		func (x ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar gio.OutputStream, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	403		func (x ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar gio.OutputStream, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
404			404
405	-	xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	405	+	var CallbackVarRef uintptr
			406	+	if CallbackVar != nil {
			407	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			408	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			409	+	CallbackVarRef = cbRefPtr
			410	+	} else {
			411	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			412	+	cbFn := *CallbackVar
			413	+	cbFn(arg0, arg1, arg2)
			414	+	}
			415	+	CallbackVarRef = purego.NewCallback(fcb)
			416	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			417	+	}
			418	+	}
			419	+
			420	+	xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
406			421
407		}	422		}
408			423

M v4/gdk/gdkcontentserializer.go +65 -3


@@ -2,6 +2,8 @@
2		package gdk	2		package gdk
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/gio"	9		"github.com/jwijenbergh/puregotk/v4/gio"

@@ -26,7 +28,37 @@ var xContentRegisterSerializer func(types.GType, string, uintptr, uintptr, uintp
26		// so applications can override the built-in serializers.	28		// so applications can override the built-in serializers.
27		func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar ContentSerializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {	29		func ContentRegisterSerializer(TypeVar types.GType, MimeTypeVar string, SerializeVar ContentSerializeFunc, DataVar uintptr, NotifyVar glib.DestroyNotify) {
28			30
29	-	xContentRegisterSerializer(TypeVar, MimeTypeVar, glib.NewCallback(SerializeVar), DataVar, glib.NewCallback(NotifyVar))	31	+	var SerializeVarRef uintptr
			32	+	if SerializeVar != nil {
			33	+	SerializeVarPtr := uintptr(unsafe.Pointer(SerializeVar))
			34	+	if cbRefPtr, ok := glib.GetCallback(SerializeVarPtr); ok {
			35	+	SerializeVarRef = cbRefPtr
			36	+	} else {
			37	+	fcb := func(arg0 uintptr) {
			38	+	cbFn := *SerializeVar
			39	+	cbFn(arg0)
			40	+	}
			41	+	SerializeVarRef = purego.NewCallback(fcb)
			42	+	glib.SaveCallback(SerializeVarPtr, SerializeVarRef)
			43	+	}
			44	+	}
			45	+
			46	+	var NotifyVarRef uintptr
			47	+	if NotifyVar != nil {
			48	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			49	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			50	+	NotifyVarRef = cbRefPtr
			51	+	} else {
			52	+	fcb := func(arg0 uintptr) {
			53	+	cbFn := *NotifyVar
			54	+	cbFn(arg0)
			55	+	}
			56	+	NotifyVarRef = purego.NewCallback(fcb)
			57	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			58	+	}
			59	+	}
			60	+
			61	+	xContentRegisterSerializer(TypeVar, MimeTypeVar, SerializeVarRef, DataVar, NotifyVarRef)
30			62
31		}	63		}
32			64

@@ -38,7 +70,22 @@ var xContentSerializeAsync func(uintptr, string, *gobject.Value, int, uintptr, u
38		// indicate a higher priority.	70		// indicate a higher priority.
39		func ContentSerializeAsync(StreamVar gio.OutputStream, MimeTypeVar string, ValueVar gobject.Value, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	71		func ContentSerializeAsync(StreamVar gio.OutputStream, MimeTypeVar string, ValueVar gobject.Value, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
40			72
41	-	xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	73	+	var CallbackVarRef uintptr
			74	+	if CallbackVar != nil {
			75	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			76	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			77	+	CallbackVarRef = cbRefPtr
			78	+	} else {
			79	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			80	+	cbFn := *CallbackVar
			81	+	cbFn(arg0, arg1, arg2)
			82	+	}
			83	+	CallbackVarRef = purego.NewCallback(fcb)
			84	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			85	+	}
			86	+	}
			87	+
			88	+	xContentSerializeAsync(StreamVar.GoPointer(), MimeTypeVar, ValueVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
42			89
43		}	90		}
44			91

@@ -204,7 +251,22 @@ var xContentSerializerSetTaskData func(uintptr, uintptr, uintptr)
204		// Associate data with the current serialization operation.	251		// Associate data with the current serialization operation.
205		func (x ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {	252		func (x ContentSerializer) SetTaskData(DataVar uintptr, NotifyVar glib.DestroyNotify) {
206			253
207	-	xContentSerializerSetTaskData(x.GoPointer(), DataVar, glib.NewCallback(NotifyVar))	254	+	var NotifyVarRef uintptr
			255	+	if NotifyVar != nil {
			256	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			257	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			258	+	NotifyVarRef = cbRefPtr
			259	+	} else {
			260	+	fcb := func(arg0 uintptr) {
			261	+	cbFn := *NotifyVar
			262	+	cbFn(arg0)
			263	+	}
			264	+	NotifyVarRef = purego.NewCallback(fcb)
			265	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			266	+	}
			267	+	}
			268	+
			269	+	xContentSerializerSetTaskData(x.GoPointer(), DataVar, NotifyVarRef)
208			270
209		}	271		}
210			272

M v4/gdk/gdkcursor.go +34 -2


@@ -2,6 +2,8 @@
2		package gdk	2		package gdk
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -82,7 +84,37 @@ var xNewCursorFromCallback func(uintptr, uintptr, uintptr, uintptr) uintptr
82		func NewCursorFromCallback(CallbackVar CursorGetTextureCallback, DataVar uintptr, DestroyVar glib.DestroyNotify, FallbackVar Cursor) Cursor {	84		func NewCursorFromCallback(CallbackVar CursorGetTextureCallback, DataVar uintptr, DestroyVar glib.DestroyNotify, FallbackVar Cursor) Cursor {
83		var cls *Cursor	85		var cls *Cursor
84			86
85	-	cret := xNewCursorFromCallback(glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DestroyVar), FallbackVar.GoPointer())	87	+	var CallbackVarRef uintptr
			88	+	if CallbackVar != nil {
			89	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			90	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			91	+	CallbackVarRef = cbRefPtr
			92	+	} else {
			93	+	fcb := func(arg0 uintptr, arg1 int, arg2 float64, arg3 int, arg4 int, arg5 int, arg6 int, arg7 uintptr) uintptr {
			94	+	cbFn := *CallbackVar
			95	+	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
			96	+	}
			97	+	CallbackVarRef = purego.NewCallback(fcb)
			98	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			99	+	}
			100	+	}
			101	+
			102	+	var DestroyVarRef uintptr
			103	+	if DestroyVar != nil {
			104	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			105	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			106	+	DestroyVarRef = cbRefPtr
			107	+	} else {
			108	+	fcb := func(arg0 uintptr) {
			109	+	cbFn := *DestroyVar
			110	+	cbFn(arg0)
			111	+	}
			112	+	DestroyVarRef = purego.NewCallback(fcb)
			113	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			114	+	}
			115	+	}
			116	+
			117	+	cret := xNewCursorFromCallback(CallbackVarRef, DataVar, DestroyVarRef, FallbackVar.GoPointer())
86			118
87		if cret == 0 {	119		if cret == 0 {
88		return nil	120		return nil

@@ -303,7 +335,7 @@ func (x *Cursor) GetPropertyHotspotY() int {
303		func (x *Cursor) SetPropertyName(value string) {	335		func (x *Cursor) SetPropertyName(value string) {
304		var v gobject.Value	336		var v gobject.Value
305		v.Init(gobject.TypeStringVal)	337		v.Init(gobject.TypeStringVal)
306	-	v.SetString(value)	338	+	v.SetString(&value)
307		x.SetProperty("name", &v)	339		x.SetProperty("name", &v)
308		}	340		}
309			341

M v4/gdk/gdkdevice.go +3 -3


@@ -436,7 +436,7 @@ func (x *Device) GetPropertyNAxes() uint {
436		func (x *Device) SetPropertyName(value string) {	436		func (x *Device) SetPropertyName(value string) {
437		var v gobject.Value	437		var v gobject.Value
438		v.Init(gobject.TypeStringVal)	438		v.Init(gobject.TypeStringVal)
439	-	v.SetString(value)	439	+	v.SetString(&value)
440		x.SetProperty("name", &v)	440		x.SetProperty("name", &v)
441		}	441		}
442			442

@@ -488,7 +488,7 @@ func (x *Device) GetPropertyNumTouches() uint {
488		func (x *Device) SetPropertyProductId(value string) {	488		func (x *Device) SetPropertyProductId(value string) {
489		var v gobject.Value	489		var v gobject.Value
490		v.Init(gobject.TypeStringVal)	490		v.Init(gobject.TypeStringVal)
491	-	v.SetString(value)	491	+	v.SetString(&value)
492		x.SetProperty("product-id", &v)	492		x.SetProperty("product-id", &v)
493		}	493		}
494			494

@@ -519,7 +519,7 @@ func (x *Device) GetPropertyScrollLockState() bool {
519		func (x *Device) SetPropertyVendorId(value string) {	519		func (x *Device) SetPropertyVendorId(value string) {
520		var v gobject.Value	520		var v gobject.Value
521		v.Init(gobject.TypeStringVal)	521		v.Init(gobject.TypeStringVal)
522	-	v.SetString(value)	522	+	v.SetString(&value)
523		x.SetProperty("vendor-id", &v)	523		x.SetProperty("vendor-id", &v)
524		}	524		}
525			525

M v4/gdk/gdkdisplay.go +3 -3


@@ -670,15 +670,15 @@ func DisplayGetDefault() *Display {
670		return cls	670		return cls
671		}	671		}
672			672
673	-	var xDisplayOpen func(string) uintptr	673	+	var xDisplayOpen func(uintptr) uintptr
674			674
675		// Opens a display.	675		// Opens a display.
676		//	676		//
677		// If opening the display fails, `NULL` is returned.	677		// If opening the display fails, `NULL` is returned.
678	-	func DisplayOpen(DisplayNameVar string) *Display {	678	+	func DisplayOpen(DisplayNameVar string) Display {
679		var cls *Display	679		var cls *Display
680			680
681	-	cret := xDisplayOpen(DisplayNameVar)	681	+	cret := xDisplayOpen(core.NullableStringToPtr(DisplayNameVar))
682			682
683		if cret == 0 {	683		if cret == 0 {
684		return nil	684		return nil

M v4/gdk/gdkdisplaymanager.go +3 -3


@@ -143,13 +143,13 @@ func (x DisplayManager) ListDisplays() glib.SList {
143		return cret	143		return cret
144		}	144		}
145			145
146	-	var xDisplayManagerOpenDisplay func(uintptr, string) uintptr	146	+	var xDisplayManagerOpenDisplay func(uintptr, uintptr) uintptr
147			147
148		// Opens a display.	148		// Opens a display.
149	-	func (x DisplayManager) OpenDisplay(NameVar string) Display {	149	+	func (x DisplayManager) OpenDisplay(NameVar string) *Display {
150		var cls *Display	150		var cls *Display
151			151
152	-	cret := xDisplayManagerOpenDisplay(x.GoPointer(), NameVar)	152	+	cret := xDisplayManagerOpenDisplay(x.GoPointer(), core.NullableStringToPtr(NameVar))
153			153
154		if cret == 0 {	154		if cret == 0 {
155		return nil	155		return nil

M v4/gdk/gdkdmabuftexturebuilder.go +16 -1


@@ -131,7 +131,22 @@ func (x DmabufTextureBuilder) Build(DestroyVar glib.DestroyNotify, DataVar uin
131		var cls *Texture	131		var cls *Texture
132		var cerr *glib.Error	132		var cerr *glib.Error
133			133
134	-	cret := xDmabufTextureBuilderBuild(x.GoPointer(), glib.NewCallbackNullable(DestroyVar), DataVar, &cerr)	134	+	var DestroyVarRef uintptr
			135	+	if DestroyVar != nil {
			136	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			137	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			138	+	DestroyVarRef = cbRefPtr
			139	+	} else {
			140	+	fcb := func(arg0 uintptr) {
			141	+	cbFn := *DestroyVar
			142	+	cbFn(arg0)
			143	+	}
			144	+	DestroyVarRef = purego.NewCallback(fcb)
			145	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			146	+	}
			147	+	}
			148	+
			149	+	cret := xDmabufTextureBuilderBuild(x.GoPointer(), DestroyVarRef, DataVar, &cerr)
135			150
136		if cret == 0 {	151		if cret == 0 {
137		return nil, cerr	152		return nil, cerr

M v4/gdk/gdkdrop.go +34 -2


@@ -2,6 +2,8 @@
2		package gdk	2		package gdk
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/gio"	9		"github.com/jwijenbergh/puregotk/v4/gio"

@@ -161,7 +163,22 @@ var xDropReadAsync func(uintptr, []string, int, uintptr, uintptr, uintptr)
161		// in a format that complies with one of the mime types.	163		// in a format that complies with one of the mime types.
162		func (x Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	164		func (x Drop) ReadAsync(MimeTypesVar []string, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
163			165
164	-	xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	166	+	var CallbackVarRef uintptr
			167	+	if CallbackVar != nil {
			168	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			169	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			170	+	CallbackVarRef = cbRefPtr
			171	+	} else {
			172	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			173	+	cbFn := *CallbackVar
			174	+	cbFn(arg0, arg1, arg2)
			175	+	}
			176	+	CallbackVarRef = purego.NewCallback(fcb)
			177	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			178	+	}
			179	+	}
			180	+
			181	+	xDropReadAsync(x.GoPointer(), MimeTypesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
165			182
166		}	183		}
167			184

@@ -203,7 +220,22 @@ var xDropReadValueAsync func(uintptr, types.GType, int, uintptr, uintptr, uintpt
203		// try to use [func@Gdk.content_deserialize_async] to convert the data.	220		// try to use [func@Gdk.content_deserialize_async] to convert the data.
204		func (x Drop) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	221		func (x Drop) ReadValueAsync(TypeVar types.GType, IoPriorityVar int, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
205			222
206	-	xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	223	+	var CallbackVarRef uintptr
			224	+	if CallbackVar != nil {
			225	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			226	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			227	+	CallbackVarRef = cbRefPtr
			228	+	} else {
			229	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			230	+	cbFn := *CallbackVar
			231	+	cbFn(arg0, arg1, arg2)
			232	+	}
			233	+	CallbackVarRef = purego.NewCallback(fcb)
			234	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			235	+	}
			236	+	}
			237	+
			238	+	xDropReadValueAsync(x.GoPointer(), TypeVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
207			239
208		}	240		}
209			241

M v4/gdk/gdkgltexture.go +16 -1


@@ -47,7 +47,22 @@ var xNewGLTexture func(uintptr, uint, int, int, uintptr, uintptr) uintptr
47		func NewGLTexture(ContextVar GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar glib.DestroyNotify, DataVar uintptr) *GLTexture {	47		func NewGLTexture(ContextVar GLContext, IdVar uint, WidthVar int, HeightVar int, DestroyVar glib.DestroyNotify, DataVar uintptr) *GLTexture {
48		var cls *GLTexture	48		var cls *GLTexture
49			49
50	-	cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, glib.NewCallback(DestroyVar), DataVar)	50	+	var DestroyVarRef uintptr
			51	+	if DestroyVar != nil {
			52	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			53	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			54	+	DestroyVarRef = cbRefPtr
			55	+	} else {
			56	+	fcb := func(arg0 uintptr) {
			57	+	cbFn := *DestroyVar
			58	+	cbFn(arg0)
			59	+	}
			60	+	DestroyVarRef = purego.NewCallback(fcb)
			61	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			62	+	}
			63	+	}
			64	+
			65	+	cret := xNewGLTexture(ContextVar.GoPointer(), IdVar, WidthVar, HeightVar, DestroyVarRef, DataVar)
51			66
52		if cret == 0 {	67		if cret == 0 {
53		return nil	68		return nil

M v4/gdk/gdkgltexturebuilder.go +16 -1


@@ -81,7 +81,22 @@ var xGLTextureBuilderBuild func(uintptr, uintptr, uintptr) uintptr
81		func (x GLTextureBuilder) Build(DestroyVar glib.DestroyNotify, DataVar uintptr) *Texture {	81		func (x GLTextureBuilder) Build(DestroyVar glib.DestroyNotify, DataVar uintptr) *Texture {
82		var cls *Texture	82		var cls *Texture
83			83
84	-	cret := xGLTextureBuilderBuild(x.GoPointer(), glib.NewCallbackNullable(DestroyVar), DataVar)	84	+	var DestroyVarRef uintptr
			85	+	if DestroyVar != nil {
			86	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			87	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			88	+	DestroyVarRef = cbRefPtr
			89	+	} else {
			90	+	fcb := func(arg0 uintptr) {
			91	+	cbFn := *DestroyVar
			92	+	cbFn(arg0)
			93	+	}
			94	+	DestroyVarRef = purego.NewCallback(fcb)
			95	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			96	+	}
			97	+	}
			98	+
			99	+	cret := xGLTextureBuilderBuild(x.GoPointer(), DestroyVarRef, DataVar)
85			100
86		if cret == 0 {	101		if cret == 0 {
87		return nil	102		return nil

M v4/gdk/gdktoplevel.go +2 -2


@@ -423,7 +423,7 @@ func (x *ToplevelBase) SetPropertyStartupId(value string) {
423		obj.Ptr = x.GoPointer()	423		obj.Ptr = x.GoPointer()
424		var v gobject.Value	424		var v gobject.Value
425		v.Init(gobject.TypeStringVal)	425		v.Init(gobject.TypeStringVal)
426	-	v.SetString(value)	426	+	v.SetString(&value)
427		obj.SetProperty("startup-id", &v)	427		obj.SetProperty("startup-id", &v)
428		}	428		}
429			429

@@ -447,7 +447,7 @@ func (x *ToplevelBase) SetPropertyTitle(value string) {
447		obj.Ptr = x.GoPointer()	447		obj.Ptr = x.GoPointer()
448		var v gobject.Value	448		var v gobject.Value
449		v.Init(gobject.TypeStringVal)	449		v.Init(gobject.TypeStringVal)
450	-	v.SetString(value)	450	+	v.SetString(&value)
451		obj.SetProperty("title", &v)	451		obj.SetProperty("title", &v)
452		}	452		}
453			453

M v4/gdkpixbuf/gdk-pixbuf-animation.go +16 -1


@@ -588,7 +588,22 @@ var xPixbufAnimationNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
588		// result of the operation.	588		// result of the operation.
589		func PixbufAnimationNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	589		func PixbufAnimationNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
590			590
591	-	xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	591	+	var CallbackVarRef uintptr
			592	+	if CallbackVar != nil {
			593	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			594	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			595	+	CallbackVarRef = cbRefPtr
			596	+	} else {
			597	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			598	+	cbFn := *CallbackVar
			599	+	cbFn(arg0, arg1, arg2)
			600	+	}
			601	+	CallbackVarRef = purego.NewCallback(fcb)
			602	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			603	+	}
			604	+	}
			605	+
			606	+	xPixbufAnimationNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
592			607
593		}	608		}
594			609

M v4/gdkpixbuf/gdk-pixbuf.go +130 -8


@@ -2,6 +2,8 @@
2		package gdkpixbuf	2		package gdkpixbuf
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/gio"	9		"github.com/jwijenbergh/puregotk/v4/gio"

@@ -219,7 +221,22 @@ var xNewPixbufFromData func([]byte, Colorspace, bool, int, int, int, int, uintpt
219		func NewPixbufFromData(DataVar []byte, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) Pixbuf {	221		func NewPixbufFromData(DataVar []byte, ColorspaceVar Colorspace, HasAlphaVar bool, BitsPerSampleVar int, WidthVar int, HeightVar int, RowstrideVar int, DestroyFnVar PixbufDestroyNotify, DestroyFnDataVar uintptr) Pixbuf {
220		var cls *Pixbuf	222		var cls *Pixbuf
221			223
222	-	cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, glib.NewCallbackNullable(DestroyFnVar), DestroyFnDataVar)	224	+	var DestroyFnVarRef uintptr
			225	+	if DestroyFnVar != nil {
			226	+	DestroyFnVarPtr := uintptr(unsafe.Pointer(DestroyFnVar))
			227	+	if cbRefPtr, ok := glib.GetCallback(DestroyFnVarPtr); ok {
			228	+	DestroyFnVarRef = cbRefPtr
			229	+	} else {
			230	+	fcb := func(arg0 []byte, arg1 uintptr) {
			231	+	cbFn := *DestroyFnVar
			232	+	cbFn(arg0, arg1)
			233	+	}
			234	+	DestroyFnVarRef = purego.NewCallback(fcb)
			235	+	glib.SaveCallback(DestroyFnVarPtr, DestroyFnVarRef)
			236	+	}
			237	+	}
			238	+
			239	+	cret := xNewPixbufFromData(DataVar, ColorspaceVar, HasAlphaVar, BitsPerSampleVar, WidthVar, HeightVar, RowstrideVar, DestroyFnVarRef, DestroyFnDataVar)
223			240
224		if cret == 0 {	241		if cret == 0 {
225		return nil	242		return nil

@@ -1144,7 +1161,22 @@ var xPixbufSaveToCallback func(uintptr, uintptr, uintptr, string, **glib.Error,
1144		// See [method@GdkPixbuf.Pixbuf.save] for more details.	1161		// See [method@GdkPixbuf.Pixbuf.save] for more details.
1145		func (x Pixbuf) SaveToCallback(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {	1162		func (x Pixbuf) SaveToCallback(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, ErrorVar **glib.Error, varArgs ...interface{}) bool {
1146			1163
1147	-	cret := xPixbufSaveToCallback(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, ErrorVar, varArgs...)	1164	+	var SaveFuncVarRef uintptr
			1165	+	if SaveFuncVar != nil {
			1166	+	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
			1167	+	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
			1168	+	SaveFuncVarRef = cbRefPtr
			1169	+	} else {
			1170	+	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
			1171	+	cbFn := *SaveFuncVar
			1172	+	return cbFn(arg0, arg1, arg2, arg3)
			1173	+	}
			1174	+	SaveFuncVarRef = purego.NewCallback(fcb)
			1175	+	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
			1176	+	}
			1177	+	}
			1178	+
			1179	+	cret := xPixbufSaveToCallback(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, ErrorVar, varArgs...)
1148		return cret	1180		return cret
1149		}	1181		}
1150			1182

@@ -1161,7 +1193,22 @@ var xPixbufSaveToCallbackv func(uintptr, uintptr, uintptr, string, []string, []s
1161		func (x Pixbuf) SaveToCallbackv(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {	1193		func (x Pixbuf) SaveToCallbackv(SaveFuncVar PixbufSaveFunc, UserDataVar uintptr, TypeVar string, OptionKeysVar []string, OptionValuesVar []string) (bool, error) {
1162		var cerr *glib.Error	1194		var cerr *glib.Error
1163			1195
1164	-	cret := xPixbufSaveToCallbackv(x.GoPointer(), glib.NewCallback(SaveFuncVar), UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)	1196	+	var SaveFuncVarRef uintptr
			1197	+	if SaveFuncVar != nil {
			1198	+	SaveFuncVarPtr := uintptr(unsafe.Pointer(SaveFuncVar))
			1199	+	if cbRefPtr, ok := glib.GetCallback(SaveFuncVarPtr); ok {
			1200	+	SaveFuncVarRef = cbRefPtr
			1201	+	} else {
			1202	+	fcb := func(arg0 []byte, arg1 uint, arg2 **glib.Error, arg3 uintptr) bool {
			1203	+	cbFn := *SaveFuncVar
			1204	+	return cbFn(arg0, arg1, arg2, arg3)
			1205	+	}
			1206	+	SaveFuncVarRef = purego.NewCallback(fcb)
			1207	+	glib.SaveCallback(SaveFuncVarPtr, SaveFuncVarRef)
			1208	+	}
			1209	+	}
			1210	+
			1211	+	cret := xPixbufSaveToCallbackv(x.GoPointer(), SaveFuncVarRef, UserDataVar, TypeVar, OptionKeysVar, OptionValuesVar, &cerr)
1165		if cerr == nil {	1212		if cerr == nil {
1166		return cret, nil	1213		return cret, nil
1167		}	1214		}

@@ -1201,7 +1248,22 @@ var xPixbufSaveToStreamAsync func(uintptr, uintptr, string, uintptr, uintptr, ui
1201		// the operation.	1248		// the operation.
1202		func (x Pixbuf) SaveToStreamAsync(StreamVar gio.OutputStream, TypeVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {	1249		func (x Pixbuf) SaveToStreamAsync(StreamVar gio.OutputStream, TypeVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr, varArgs ...interface{}) {
1203			1250
1204	-	xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, varArgs...)	1251	+	var CallbackVarRef uintptr
			1252	+	if CallbackVar != nil {
			1253	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1254	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1255	+	CallbackVarRef = cbRefPtr
			1256	+	} else {
			1257	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1258	+	cbFn := *CallbackVar
			1259	+	cbFn(arg0, arg1, arg2)
			1260	+	}
			1261	+	CallbackVarRef = purego.NewCallback(fcb)
			1262	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1263	+	}
			1264	+	}
			1265	+
			1266	+	xPixbufSaveToStreamAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar, varArgs...)
1205			1267
1206		}	1268		}
1207			1269

@@ -1237,7 +1299,22 @@ var xPixbufSaveToStreamvAsync func(uintptr, uintptr, string, []string, []string,
1237		// the operation.	1299		// the operation.
1238		func (x Pixbuf) SaveToStreamvAsync(StreamVar gio.OutputStream, TypeVar string, OptionKeysVar []string, OptionValuesVar []string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1300		func (x Pixbuf) SaveToStreamvAsync(StreamVar gio.OutputStream, TypeVar string, OptionKeysVar []string, OptionValuesVar []string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
1239			1301
1240	-	xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1302	+	var CallbackVarRef uintptr
			1303	+	if CallbackVar != nil {
			1304	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1305	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1306	+	CallbackVarRef = cbRefPtr
			1307	+	} else {
			1308	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1309	+	cbFn := *CallbackVar
			1310	+	cbFn(arg0, arg1, arg2)
			1311	+	}
			1312	+	CallbackVarRef = purego.NewCallback(fcb)
			1313	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1314	+	}
			1315	+	}
			1316	+
			1317	+	xPixbufSaveToStreamvAsync(x.GoPointer(), StreamVar.GoPointer(), TypeVar, OptionKeysVar, OptionValuesVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1241			1318
1242		}	1319		}
1243			1320

@@ -1627,7 +1704,22 @@ var xPixbufGetFileInfoAsync func(string, uintptr, uintptr, uintptr)
1627		// get the result of the operation.	1704		// get the result of the operation.
1628		func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	1705		func PixbufGetFileInfoAsync(FilenameVar string, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
1629			1706
1630	-	xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1707	+	var CallbackVarRef uintptr
			1708	+	if CallbackVar != nil {
			1709	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1710	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1711	+	CallbackVarRef = cbRefPtr
			1712	+	} else {
			1713	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1714	+	cbFn := *CallbackVar
			1715	+	cbFn(arg0, arg1, arg2)
			1716	+	}
			1717	+	CallbackVarRef = purego.NewCallback(fcb)
			1718	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1719	+	}
			1720	+	}
			1721	+
			1722	+	xPixbufGetFileInfoAsync(FilenameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1631			1723
1632		}	1724		}
1633			1725

@@ -1694,7 +1786,22 @@ var xPixbufNewFromStreamAsync func(uintptr, uintptr, uintptr, uintptr)
1694		// the operation.	1786		// the operation.
1695		func PixbufNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	1787		func PixbufNewFromStreamAsync(StreamVar gio.InputStream, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1696			1788
1697	-	xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1789	+	var CallbackVarRef uintptr
			1790	+	if CallbackVar != nil {
			1791	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1792	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1793	+	CallbackVarRef = cbRefPtr
			1794	+	} else {
			1795	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1796	+	cbFn := *CallbackVar
			1797	+	cbFn(arg0, arg1, arg2)
			1798	+	}
			1799	+	CallbackVarRef = purego.NewCallback(fcb)
			1800	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1801	+	}
			1802	+	}
			1803	+
			1804	+	xPixbufNewFromStreamAsync(StreamVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1698			1805
1699		}	1806		}
1700			1807

@@ -1709,7 +1816,22 @@ var xPixbufNewFromStreamAtScaleAsync func(uintptr, int, int, bool, uintptr, uint
1709		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.	1816		// You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
1710		func PixbufNewFromStreamAtScaleAsync(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	1817		func PixbufNewFromStreamAtScaleAsync(StreamVar gio.InputStream, WidthVar int, HeightVar int, PreserveAspectRatioVar bool, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
1711			1818
1712	-	xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1819	+	var CallbackVarRef uintptr
			1820	+	if CallbackVar != nil {
			1821	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1822	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1823	+	CallbackVarRef = cbRefPtr
			1824	+	} else {
			1825	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1826	+	cbFn := *CallbackVar
			1827	+	cbFn(arg0, arg1, arg2)
			1828	+	}
			1829	+	CallbackVarRef = purego.NewCallback(fcb)
			1830	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1831	+	}
			1832	+	}
			1833	+
			1834	+	xPixbufNewFromStreamAtScaleAsync(StreamVar.GoPointer(), WidthVar, HeightVar, PreserveAspectRatioVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1713			1835
1714		}	1836		}
1715			1837

M v4/gio/gappinfo.go +51 -6


@@ -1435,7 +1435,7 @@ var XGAppInfoShouldShow func(uintptr) bool
1435		var XGAppInfoSupportsFiles func(uintptr) bool	1435		var XGAppInfoSupportsFiles func(uintptr) bool
1436		var XGAppInfoSupportsUris func(uintptr) bool	1436		var XGAppInfoSupportsUris func(uintptr) bool
1437			1437
1438	-	var xAppInfoCreateFromCommandline func(string, string, AppInfoCreateFlags, **glib.Error) uintptr	1438	+	var xAppInfoCreateFromCommandline func(string, uintptr, AppInfoCreateFlags, **glib.Error) uintptr
1439			1439
1440		// Creates a new [iface@Gio.AppInfo] from the given information.	1440		// Creates a new [iface@Gio.AppInfo] from the given information.
1441		//	1441		//

@@ -1446,11 +1446,11 @@ var xAppInfoCreateFromCommandline func(string, string, AppInfoCreateFlags, **gli
1446		// being swallowed by `Exec` key unquoting. See	1446		// being swallowed by `Exec` key unquoting. See
1447		// [the specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)	1447		// [the specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)
1448		// for exact quoting rules.	1448		// for exact quoting rules.
1449	-	func AppInfoCreateFromCommandline(CommandlineVar string, ApplicationNameVar string, FlagsVar AppInfoCreateFlags) (*AppInfoBase, error) {	1449	+	func AppInfoCreateFromCommandline(CommandlineVar string, ApplicationNameVar string, FlagsVar AppInfoCreateFlags) (AppInfoBase, error) {
1450		var cls *AppInfoBase	1450		var cls *AppInfoBase
1451		var cerr *glib.Error	1451		var cerr *glib.Error
1452			1452
1453	-	cret := xAppInfoCreateFromCommandline(CommandlineVar, ApplicationNameVar, FlagsVar, &cerr)	1453	+	cret := xAppInfoCreateFromCommandline(CommandlineVar, core.NullableStringToPtr(ApplicationNameVar), FlagsVar, &cerr)
1454			1454
1455		if cret == 0 {	1455		if cret == 0 {
1456		return nil, cerr	1456		return nil, cerr

@@ -1519,7 +1519,22 @@ var xAppInfoGetDefaultForTypeAsync func(string, bool, uintptr, uintptr, uintptr)
1519		// type.	1519		// type.
1520		func AppInfoGetDefaultForTypeAsync(ContentTypeVar string, MustSupportUrisVar bool, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1520		func AppInfoGetDefaultForTypeAsync(ContentTypeVar string, MustSupportUrisVar bool, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1521			1521
1522	-	xAppInfoGetDefaultForTypeAsync(ContentTypeVar, MustSupportUrisVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1522	+	var CallbackVarRef uintptr
			1523	+	if CallbackVar != nil {
			1524	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1525	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1526	+	CallbackVarRef = cbRefPtr
			1527	+	} else {
			1528	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1529	+	cbFn := *CallbackVar
			1530	+	cbFn(arg0, arg1, arg2)
			1531	+	}
			1532	+	CallbackVarRef = purego.NewCallback(fcb)
			1533	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1534	+	}
			1535	+	}
			1536	+
			1537	+	xAppInfoGetDefaultForTypeAsync(ContentTypeVar, MustSupportUrisVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1523			1538
1524		}	1539		}
1525			1540

@@ -1575,7 +1590,22 @@ var xAppInfoGetDefaultForUriSchemeAsync func(string, uintptr, uintptr, uintptr)
1575		// `ftp` or `sip`.	1590		// `ftp` or `sip`.
1576		func AppInfoGetDefaultForUriSchemeAsync(UriSchemeVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1591		func AppInfoGetDefaultForUriSchemeAsync(UriSchemeVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1577			1592
1578	-	xAppInfoGetDefaultForUriSchemeAsync(UriSchemeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1593	+	var CallbackVarRef uintptr
			1594	+	if CallbackVar != nil {
			1595	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1596	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1597	+	CallbackVarRef = cbRefPtr
			1598	+	} else {
			1599	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1600	+	cbFn := *CallbackVar
			1601	+	cbFn(arg0, arg1, arg2)
			1602	+	}
			1603	+	CallbackVarRef = purego.NewCallback(fcb)
			1604	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1605	+	}
			1606	+	}
			1607	+
			1608	+	xAppInfoGetDefaultForUriSchemeAsync(UriSchemeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1579			1609
1580		}	1610		}
1581			1611

@@ -1663,7 +1693,22 @@ var xAppInfoLaunchDefaultForUriAsync func(string, uintptr, uintptr, uintptr, uin
1663		// in receiving error information from their activation.	1693		// in receiving error information from their activation.
1664		func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar AppLaunchContext, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	1694		func AppInfoLaunchDefaultForUriAsync(UriVar string, ContextVar AppLaunchContext, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1665			1695
1666	-	xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1696	+	var CallbackVarRef uintptr
			1697	+	if CallbackVar != nil {
			1698	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1699	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1700	+	CallbackVarRef = cbRefPtr
			1701	+	} else {
			1702	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1703	+	cbFn := *CallbackVar
			1704	+	cbFn(arg0, arg1, arg2)
			1705	+	}
			1706	+	CallbackVarRef = purego.NewCallback(fcb)
			1707	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1708	+	}
			1709	+	}
			1710	+
			1711	+	xAppInfoLaunchDefaultForUriAsync(UriVar, ContextVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1667			1712
1668		}	1713		}
1669			1714

M v4/gio/gapplication.go +27 -27


@@ -649,7 +649,7 @@ func ApplicationNewFromInternalPtr(ptr uintptr) *Application {
649		return cls	649		return cls
650		}	650		}
651			651
652	-	var xNewApplication func(string, ApplicationFlags) uintptr	652	+	var xNewApplication func(uintptr, ApplicationFlags) uintptr
653			653
654		// Creates a new #GApplication instance.	654		// Creates a new #GApplication instance.
655		//	655		//

@@ -658,10 +658,10 @@ var xNewApplication func(string, ApplicationFlags) uintptr
658		//	658		//
659		// If no application ID is given then some features of #GApplication	659		// If no application ID is given then some features of #GApplication
660		// (most notably application uniqueness) will be disabled.	660		// (most notably application uniqueness) will be disabled.
661	-	func NewApplication(ApplicationIdVar string, FlagsVar ApplicationFlags) *Application {	661	+	func NewApplication(ApplicationIdVar string, FlagsVar ApplicationFlags) Application {
662		var cls *Application	662		var cls *Application
663			663
664	-	cret := xNewApplication(ApplicationIdVar, FlagsVar)	664	+	cret := xNewApplication(core.NullableStringToPtr(ApplicationIdVar), FlagsVar)
665			665
666		if cret == 0 {	666		if cret == 0 {
667		return nil	667		return nil

@@ -685,7 +685,7 @@ func (x *Application) Activate() {
685			685
686		}	686		}
687			687
688	-	var xApplicationAddMainOption func(uintptr, string, byte, glib.OptionFlags, glib.OptionArg, string, string)	688	+	var xApplicationAddMainOption func(uintptr, string, byte, glib.OptionFlags, glib.OptionArg, string, uintptr)
689			689
690		// Add an option to be handled by @application.	690		// Add an option to be handled by @application.
691		//	691		//

@@ -700,9 +700,9 @@ var xApplicationAddMainOption func(uintptr, string, byte, glib.OptionFlags, glib
700		// g_application_add_main_option_entries() for more details.	700		// g_application_add_main_option_entries() for more details.
701		//	701		//
702		// See #GOptionEntry for more documentation of the arguments.	702		// See #GOptionEntry for more documentation of the arguments.
703	-	func (x *Application) AddMainOption(LongNameVar string, ShortNameVar byte, FlagsVar glib.OptionFlags, ArgVar glib.OptionArg, DescriptionVar string, ArgDescriptionVar string) {	703	+	func (x Application) AddMainOption(LongNameVar string, ShortNameVar byte, FlagsVar glib.OptionFlags, ArgVar glib.OptionArg, DescriptionVar string, ArgDescriptionVar string) {
704			704
705	-	xApplicationAddMainOption(x.GoPointer(), LongNameVar, ShortNameVar, FlagsVar, ArgVar, DescriptionVar, ArgDescriptionVar)	705	+	xApplicationAddMainOption(x.GoPointer(), LongNameVar, ShortNameVar, FlagsVar, ArgVar, DescriptionVar, core.NullableStringToPtr(ArgDescriptionVar))
706			706
707		}	707		}
708			708

@@ -1178,7 +1178,7 @@ func (x *Application) Run(ArgcVar int, ArgvVar []string) int {
1178		return cret	1178		return cret
1179		}	1179		}
1180			1180
1181	-	var xApplicationSendNotification func(uintptr, string, uintptr)	1181	+	var xApplicationSendNotification func(uintptr, uintptr, uintptr)
1182			1182
1183		// Sends a notification on behalf of @application to the desktop shell.	1183		// Sends a notification on behalf of @application to the desktop shell.
1184		// There is no guarantee that the notification is displayed immediately,	1184		// There is no guarantee that the notification is displayed immediately,

@@ -1209,9 +1209,9 @@ var xApplicationSendNotification func(uintptr, string, uintptr)
1209		//	1209		//
1210		// It is an error to call this function if @application has no	1210		// It is an error to call this function if @application has no
1211		// application ID.	1211		// application ID.
1212	-	func (x Application) SendNotification(IdVar string, NotificationVar Notification) {	1212	+	func (x Application) SendNotification(IdVar string, NotificationVar *Notification) {
1213			1213
1214	-	xApplicationSendNotification(x.GoPointer(), IdVar, NotificationVar.GoPointer())	1214	+	xApplicationSendNotification(x.GoPointer(), core.NullableStringToPtr(IdVar), NotificationVar.GoPointer())
1215			1215
1216		}	1216		}
1217			1217

@@ -1225,7 +1225,7 @@ func (x *Application) SetActionGroup(ActionGroupVar ActionGroup) {
1225			1225
1226		}	1226		}
1227			1227
1228	-	var xApplicationSetApplicationId func(uintptr, string)	1228	+	var xApplicationSetApplicationId func(uintptr, uintptr)
1229			1229
1230		// Sets the unique identifier for @application.	1230		// Sets the unique identifier for @application.
1231		//	1231		//

@@ -1234,9 +1234,9 @@ var xApplicationSetApplicationId func(uintptr, string)
1234		//	1234		//
1235		// If non-%NULL, the application id must be valid. See	1235		// If non-%NULL, the application id must be valid. See
1236		// g_application_id_is_valid().	1236		// g_application_id_is_valid().
1237	-	func (x *Application) SetApplicationId(ApplicationIdVar string) {	1237	+	func (x Application) SetApplicationId(ApplicationIdVar string) {
1238			1238
1239	-	xApplicationSetApplicationId(x.GoPointer(), ApplicationIdVar)	1239	+	xApplicationSetApplicationId(x.GoPointer(), core.NullableStringToPtr(ApplicationIdVar))
1240			1240
1241		}	1241		}
1242			1242

@@ -1284,18 +1284,18 @@ func (x *Application) SetInactivityTimeout(InactivityTimeoutVar uint) {
1284			1284
1285		}	1285		}
1286			1286
1287	-	var xApplicationSetOptionContextDescription func(uintptr, string)	1287	+	var xApplicationSetOptionContextDescription func(uintptr, uintptr)
1288			1288
1289		// Adds a description to the @application option context.	1289		// Adds a description to the @application option context.
1290		//	1290		//
1291		// See g_option_context_set_description() for more information.	1291		// See g_option_context_set_description() for more information.
1292	-	func (x *Application) SetOptionContextDescription(DescriptionVar string) {	1292	+	func (x Application) SetOptionContextDescription(DescriptionVar string) {
1293			1293
1294	-	xApplicationSetOptionContextDescription(x.GoPointer(), DescriptionVar)	1294	+	xApplicationSetOptionContextDescription(x.GoPointer(), core.NullableStringToPtr(DescriptionVar))
1295			1295
1296		}	1296		}
1297			1297
1298	-	var xApplicationSetOptionContextParameterString func(uintptr, string)	1298	+	var xApplicationSetOptionContextParameterString func(uintptr, uintptr)
1299			1299
1300		// Sets the parameter string to be used by the commandline handling of @application.	1300		// Sets the parameter string to be used by the commandline handling of @application.
1301		//	1301		//

@@ -1303,24 +1303,24 @@ var xApplicationSetOptionContextParameterString func(uintptr, string)
1303		// when the internal #GOptionContext of @application is created.	1303		// when the internal #GOptionContext of @application is created.
1304		//	1304		//
1305		// See g_option_context_new() for more information about @parameter_string.	1305		// See g_option_context_new() for more information about @parameter_string.
1306	-	func (x *Application) SetOptionContextParameterString(ParameterStringVar string) {	1306	+	func (x Application) SetOptionContextParameterString(ParameterStringVar string) {
1307			1307
1308	-	xApplicationSetOptionContextParameterString(x.GoPointer(), ParameterStringVar)	1308	+	xApplicationSetOptionContextParameterString(x.GoPointer(), core.NullableStringToPtr(ParameterStringVar))
1309			1309
1310		}	1310		}
1311			1311
1312	-	var xApplicationSetOptionContextSummary func(uintptr, string)	1312	+	var xApplicationSetOptionContextSummary func(uintptr, uintptr)
1313			1313
1314		// Adds a summary to the @application option context.	1314		// Adds a summary to the @application option context.
1315		//	1315		//
1316		// See g_option_context_set_summary() for more information.	1316		// See g_option_context_set_summary() for more information.
1317	-	func (x *Application) SetOptionContextSummary(SummaryVar string) {	1317	+	func (x Application) SetOptionContextSummary(SummaryVar string) {
1318			1318
1319	-	xApplicationSetOptionContextSummary(x.GoPointer(), SummaryVar)	1319	+	xApplicationSetOptionContextSummary(x.GoPointer(), core.NullableStringToPtr(SummaryVar))
1320			1320
1321		}	1321		}
1322			1322
1323	-	var xApplicationSetResourceBasePath func(uintptr, string)	1323	+	var xApplicationSetResourceBasePath func(uintptr, uintptr)
1324			1324
1325		// Sets (or unsets) the base resource path of @application.	1325		// Sets (or unsets) the base resource path of @application.
1326		//	1326		//

@@ -1355,9 +1355,9 @@ var xApplicationSetResourceBasePath func(uintptr, string)
1355		// this function during the instance initialization. Alternatively, you	1355		// this function during the instance initialization. Alternatively, you
1356		// can call this function in the #GApplicationClass.startup virtual function,	1356		// can call this function in the #GApplicationClass.startup virtual function,
1357		// before chaining up to the parent implementation.	1357		// before chaining up to the parent implementation.
1358	-	func (x *Application) SetResourceBasePath(ResourcePathVar string) {	1358	+	func (x Application) SetResourceBasePath(ResourcePathVar string) {
1359			1359
1360	-	xApplicationSetResourceBasePath(x.GoPointer(), ResourcePathVar)	1360	+	xApplicationSetResourceBasePath(x.GoPointer(), core.NullableStringToPtr(ResourcePathVar))
1361			1361
1362		}	1362		}
1363			1363

@@ -1437,7 +1437,7 @@ func (c *Application) SetGoPointer(ptr uintptr) {
1437		func (x *Application) SetPropertyApplicationId(value string) {	1437		func (x *Application) SetPropertyApplicationId(value string) {
1438		var v gobject.Value	1438		var v gobject.Value
1439		v.Init(gobject.TypeStringVal)	1439		v.Init(gobject.TypeStringVal)
1440	-	v.SetString(value)	1440	+	v.SetString(&value)
1441		x.SetProperty("application-id", &v)	1441		x.SetProperty("application-id", &v)
1442		}	1442		}
1443			1443

@@ -1496,7 +1496,7 @@ func (x *Application) GetPropertyIsRemote() bool {
1496		func (x *Application) SetPropertyResourceBasePath(value string) {	1496		func (x *Application) SetPropertyResourceBasePath(value string) {
1497		var v gobject.Value	1497		var v gobject.Value
1498		v.Init(gobject.TypeStringVal)	1498		v.Init(gobject.TypeStringVal)
1499	-	v.SetString(value)	1499	+	v.SetString(&value)
1500		x.SetProperty("resource-base-path", &v)	1500		x.SetProperty("resource-base-path", &v)
1501		}	1501		}
1502			1502

@@ -1513,7 +1513,7 @@ func (x *Application) GetPropertyResourceBasePath() string {
1513		func (x *Application) SetPropertyVersion(value string) {	1513		func (x *Application) SetPropertyVersion(value string) {
1514		var v gobject.Value	1514		var v gobject.Value
1515		v.Init(gobject.TypeStringVal)	1515		v.Init(gobject.TypeStringVal)
1516	-	v.SetString(value)	1516	+	v.SetString(&value)
1517		x.SetProperty("version", &v)	1517		x.SetProperty("version", &v)
1518		}	1518		}
1519			1519

M v4/gio/gasyncinitable.go +16 -1


@@ -306,7 +306,22 @@ var xAsyncInitableNewvAsync func(types.GType, uint, *gobject.Parameter, int, uin
306		// for any errors.	306		// for any errors.
307		func AsyncInitableNewvAsync(ObjectTypeVar types.GType, NParametersVar uint, ParametersVar gobject.Parameter, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	307		func AsyncInitableNewvAsync(ObjectTypeVar types.GType, NParametersVar uint, ParametersVar gobject.Parameter, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
308			308
309	-	xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	309	+	var CallbackVarRef uintptr
			310	+	if CallbackVar != nil {
			311	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			312	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			313	+	CallbackVarRef = cbRefPtr
			314	+	} else {
			315	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			316	+	cbFn := *CallbackVar
			317	+	cbFn(arg0, arg1, arg2)
			318	+	}
			319	+	CallbackVarRef = purego.NewCallback(fcb)
			320	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			321	+	}
			322	+	}
			323	+
			324	+	xAsyncInitableNewvAsync(ObjectTypeVar, NParametersVar, ParametersVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
310			325
311		}	326		}
312			327

M v4/gio/gbufferedinputstream.go +16 -1


@@ -341,7 +341,22 @@ var xBufferedInputStreamFillAsync func(uintptr, int, int, uintptr, uintptr, uint
341		// of bytes that are required to fill the buffer.	341		// of bytes that are required to fill the buffer.
342		func (x BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	342		func (x BufferedInputStream) FillAsync(CountVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
343			343
344	-	xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	344	+	var CallbackVarRef uintptr
			345	+	if CallbackVar != nil {
			346	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			347	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			348	+	CallbackVarRef = cbRefPtr
			349	+	} else {
			350	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			351	+	cbFn := *CallbackVar
			352	+	cbFn(arg0, arg1, arg2)
			353	+	}
			354	+	CallbackVarRef = purego.NewCallback(fcb)
			355	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			356	+	}
			357	+	}
			358	+
			359	+	xBufferedInputStreamFillAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
345			360
346		}	361		}
347			362

M v4/gio/gcancellable.go +31 -1


@@ -290,7 +290,37 @@ var xCancellableConnect func(uintptr, uintptr, uintptr, uintptr) uint32
290		// - [method@Gio.Cancellable.release_fd]	290		// - [method@Gio.Cancellable.release_fd]
291		func (x Cancellable) Connect(CallbackVar gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {	291		func (x Cancellable) Connect(CallbackVar gobject.Callback, DataVar uintptr, DataDestroyFuncVar *glib.DestroyNotify) uint32 {
292			292
293	-	cret := xCancellableConnect(x.GoPointer(), glib.NewCallback(CallbackVar), DataVar, glib.NewCallbackNullable(DataDestroyFuncVar))	293	+	var CallbackVarRef uintptr
			294	+	if CallbackVar != nil {
			295	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			296	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			297	+	CallbackVarRef = cbRefPtr
			298	+	} else {
			299	+	fcb := func() {
			300	+	cbFn := *CallbackVar
			301	+	cbFn()
			302	+	}
			303	+	CallbackVarRef = purego.NewCallback(fcb)
			304	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			305	+	}
			306	+	}
			307	+
			308	+	var DataDestroyFuncVarRef uintptr
			309	+	if DataDestroyFuncVar != nil {
			310	+	DataDestroyFuncVarPtr := uintptr(unsafe.Pointer(DataDestroyFuncVar))
			311	+	if cbRefPtr, ok := glib.GetCallback(DataDestroyFuncVarPtr); ok {
			312	+	DataDestroyFuncVarRef = cbRefPtr
			313	+	} else {
			314	+	fcb := func(arg0 uintptr) {
			315	+	cbFn := *DataDestroyFuncVar
			316	+	cbFn(arg0)
			317	+	}
			318	+	DataDestroyFuncVarRef = purego.NewCallback(fcb)
			319	+	glib.SaveCallback(DataDestroyFuncVarPtr, DataDestroyFuncVarRef)
			320	+	}
			321	+	}
			322	+
			323	+	cret := xCancellableConnect(x.GoPointer(), CallbackVarRef, DataVar, DataDestroyFuncVarRef)
294		return cret	324		return cret
295		}	325		}
296			326

M v4/gio/gcharsetconverter.go +2 -2


@@ -104,7 +104,7 @@ func (c *CharsetConverter) SetGoPointer(ptr uintptr) {
104		func (x *CharsetConverter) SetPropertyFromCharset(value string) {	104		func (x *CharsetConverter) SetPropertyFromCharset(value string) {
105		var v gobject.Value	105		var v gobject.Value
106		v.Init(gobject.TypeStringVal)	106		v.Init(gobject.TypeStringVal)
107	-	v.SetString(value)	107	+	v.SetString(&value)
108		x.SetProperty("from-charset", &v)	108		x.SetProperty("from-charset", &v)
109		}	109		}
110			110

@@ -121,7 +121,7 @@ func (x *CharsetConverter) GetPropertyFromCharset() string {
121		func (x *CharsetConverter) SetPropertyToCharset(value string) {	121		func (x *CharsetConverter) SetPropertyToCharset(value string) {
122		var v gobject.Value	122		var v gobject.Value
123		v.Init(gobject.TypeStringVal)	123		v.Init(gobject.TypeStringVal)
124	-	v.SetString(value)	124	+	v.SetString(&value)
125		x.SetProperty("to-charset", &v)	125		x.SetProperty("to-charset", &v)
126		}	126		}
127			127

M v4/gio/gcontenttype.go +3 -3


@@ -108,15 +108,15 @@ func ContentTypeGetSymbolicIcon(TypeVar string) *IconBase {
108		return cls	108		return cls
109		}	109		}
110			110
111	-	var xContentTypeGuess func(string, []byte, uint, *bool) string	111	+	var xContentTypeGuess func(uintptr, []byte, uint, *bool) string
112			112
113		// Guesses the content type based on example data. If the function is	113		// Guesses the content type based on example data. If the function is
114		// uncertain, @result_uncertain will be set to %TRUE. Either @filename	114		// uncertain, @result_uncertain will be set to %TRUE. Either @filename
115		// or @data may be %NULL, in which case the guess will be based solely	115		// or @data may be %NULL, in which case the guess will be based solely
116		// on the other argument.	116		// on the other argument.
117	-	func ContentTypeGuess(FilenameVar string, DataVar []byte, DataSizeVar uint, ResultUncertainVar *bool) string {	117	+	func ContentTypeGuess(FilenameVar string, DataVar []byte, DataSizeVar uint, ResultUncertainVar bool) string {
118			118
119	-	cret := xContentTypeGuess(FilenameVar, DataVar, DataSizeVar, ResultUncertainVar)	119	+	cret := xContentTypeGuess(core.NullableStringToPtr(FilenameVar), DataVar, DataSizeVar, ResultUncertainVar)
120		return cret	120		return cret
121		}	121		}
122			122

M v4/gio/gdatainputstream.go +48 -3


@@ -309,7 +309,22 @@ var xDataInputStreamReadLineAsync func(uintptr, int, uintptr, uintptr, uintptr)
309		// the result of the operation.	309		// the result of the operation.
310		func (x DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	310		func (x DataInputStream) ReadLineAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
311			311
312	-	xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	312	+	var CallbackVarRef uintptr
			313	+	if CallbackVar != nil {
			314	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			315	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			316	+	CallbackVarRef = cbRefPtr
			317	+	} else {
			318	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			319	+	cbFn := *CallbackVar
			320	+	cbFn(arg0, arg1, arg2)
			321	+	}
			322	+	CallbackVarRef = purego.NewCallback(fcb)
			323	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			324	+	}
			325	+	}
			326	+
			327	+	xDataInputStreamReadLineAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
313			328
314		}	329		}
315			330

@@ -465,7 +480,22 @@ var xDataInputStreamReadUntilAsync func(uintptr, string, int, uintptr, uintptr,
465		// g_data_input_stream_read_upto_async() instead.	480		// g_data_input_stream_read_upto_async() instead.
466		func (x DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	481		func (x DataInputStream) ReadUntilAsync(StopCharsVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
467			482
468	-	xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	483	+	var CallbackVarRef uintptr
			484	+	if CallbackVar != nil {
			485	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			486	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			487	+	CallbackVarRef = cbRefPtr
			488	+	} else {
			489	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			490	+	cbFn := *CallbackVar
			491	+	cbFn(arg0, arg1, arg2)
			492	+	}
			493	+	CallbackVarRef = purego.NewCallback(fcb)
			494	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			495	+	}
			496	+	}
			497	+
			498	+	xDataInputStreamReadUntilAsync(x.GoPointer(), StopCharsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
469			499
470		}	500		}
471			501

@@ -527,7 +557,22 @@ var xDataInputStreamReadUptoAsync func(uintptr, string, int, int, uintptr, uintp
527		// the result of the operation.	557		// the result of the operation.
528		func (x DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	558		func (x DataInputStream) ReadUptoAsync(StopCharsVar string, StopCharsLenVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
529			559
530	-	xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	560	+	var CallbackVarRef uintptr
			561	+	if CallbackVar != nil {
			562	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			563	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			564	+	CallbackVarRef = cbRefPtr
			565	+	} else {
			566	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			567	+	cbFn := *CallbackVar
			568	+	cbFn(arg0, arg1, arg2)
			569	+	}
			570	+	CallbackVarRef = purego.NewCallback(fcb)
			571	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			572	+	}
			573	+	}
			574	+
			575	+	xDataInputStreamReadUptoAsync(x.GoPointer(), StopCharsVar, StopCharsLenVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
531			576
532		}	577		}
533			578

M v4/gio/gdbusactiongroup.go +3 -3


@@ -302,7 +302,7 @@ func (x DBusActionGroup) ChangeActionStateFull(ActionNameVar string, ValueVar
302			302
303		}	303		}
304			304
305	-	var xDBusActionGroupGet func(uintptr, string, string) uintptr	305	+	var xDBusActionGroupGet func(uintptr, uintptr, string) uintptr
306			306
307		// Obtains a #GDBusActionGroup for the action group which is exported at	307		// Obtains a #GDBusActionGroup for the action group which is exported at
308		// the given @bus_name and @object_path.	308		// the given @bus_name and @object_path.

@@ -317,10 +317,10 @@ var xDBusActionGroupGet func(uintptr, string, string) uintptr
317		// already be filled in. The correct thing to do is connect the signals	317		// already be filled in. The correct thing to do is connect the signals
318		// for the action group to monitor for changes and then to call	318		// for the action group to monitor for changes and then to call
319		// g_action_group_list_actions() to get the initial list.	319		// g_action_group_list_actions() to get the initial list.
320	-	func DBusActionGroupGet(ConnectionVar DBusConnection, BusNameVar string, ObjectPathVar string) DBusActionGroup {	320	+	func DBusActionGroupGet(ConnectionVar DBusConnection, BusNameVar string, ObjectPathVar string) *DBusActionGroup {
321		var cls *DBusActionGroup	321		var cls *DBusActionGroup
322			322
323	-	cret := xDBusActionGroupGet(ConnectionVar.GoPointer(), BusNameVar, ObjectPathVar)	323	+	cret := xDBusActionGroupGet(ConnectionVar.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar)
324			324
325		if cret == 0 {	325		if cret == 0 {
326		return nil	326		return nil

M v4/gio/gdbusaddress.go +18 -1


@@ -2,6 +2,8 @@
2		package gio	2		package gio
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -56,7 +58,22 @@ var xDbusAddressGetStream func(string, uintptr, uintptr, uintptr)
56		// g_dbus_address_get_stream_sync() for the synchronous version.	58		// g_dbus_address_get_stream_sync() for the synchronous version.
57		func DbusAddressGetStream(AddressVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	59		func DbusAddressGetStream(AddressVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
58			60
59	-	xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	61	+	var CallbackVarRef uintptr
			62	+	if CallbackVar != nil {
			63	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			64	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			65	+	CallbackVarRef = cbRefPtr
			66	+	} else {
			67	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			68	+	cbFn := *CallbackVar
			69	+	cbFn(arg0, arg1, arg2)
			70	+	}
			71	+	CallbackVarRef = purego.NewCallback(fcb)
			72	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			73	+	}
			74	+	}
			75	+
			76	+	xDbusAddressGetStream(AddressVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
60			77
61		}	78		}
62			79

M v4/gio/gdbusconnection.go +244 -34


@@ -225,7 +225,22 @@ var xBusGet func(BusType, uintptr, uintptr, uintptr)
225		// the synchronous version.	225		// the synchronous version.
226		func BusGet(BusTypeVar BusType, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	226		func BusGet(BusTypeVar BusType, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
227			227
228	-	xBusGet(BusTypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	228	+	var CallbackVarRef uintptr
			229	+	if CallbackVar != nil {
			230	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			231	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			232	+	CallbackVarRef = cbRefPtr
			233	+	} else {
			234	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			235	+	cbFn := *CallbackVar
			236	+	cbFn(arg0, arg1, arg2)
			237	+	}
			238	+	CallbackVarRef = purego.NewCallback(fcb)
			239	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			240	+	}
			241	+	}
			242	+
			243	+	xBusGet(BusTypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
229			244
230		}	245		}
231			246

@@ -446,7 +461,7 @@ func NewDBusConnectionForAddressSync(AddressVar string, FlagsVar DBusConnectionF
446			461
447		}	462		}
448			463
449	-	var xNewDBusConnectionSync func(uintptr, string, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr	464	+	var xNewDBusConnectionSync func(uintptr, uintptr, DBusConnectionFlags, uintptr, uintptr, **glib.Error) uintptr
450			465
451		// Synchronously sets up a D-Bus connection for exchanging D-Bus messages	466		// Synchronously sets up a D-Bus connection for exchanging D-Bus messages
452		// with the end represented by @stream.	467		// with the end represented by @stream.

@@ -463,11 +478,11 @@ var xNewDBusConnectionSync func(uintptr, string, DBusConnectionFlags, uintptr, u
463		//	478		//
464		// This is a synchronous failable constructor. See	479		// This is a synchronous failable constructor. See
465		// g_dbus_connection_new() for the asynchronous version.	480		// g_dbus_connection_new() for the asynchronous version.
466	-	func NewDBusConnectionSync(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (DBusConnection, error) {	481	+	func NewDBusConnectionSync(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable) (*DBusConnection, error) {
467		var cls *DBusConnection	482		var cls *DBusConnection
468		var cerr *glib.Error	483		var cerr *glib.Error
469			484
470	-	cret := xNewDBusConnectionSync(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)	485	+	cret := xNewDBusConnectionSync(StreamVar.GoPointer(), core.NullableStringToPtr(GuidVar), FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), &cerr)
471			486
472		if cret == 0 {	487		if cret == 0 {
473		return nil, cerr	488		return nil, cerr

@@ -512,11 +527,41 @@ var xDBusConnectionAddFilter func(uintptr, uintptr, uintptr, uintptr) uint
512		// destroyed.)	527		// destroyed.)
513		func (x DBusConnection) AddFilter(FilterFunctionVar DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {	528		func (x DBusConnection) AddFilter(FilterFunctionVar DBusMessageFilterFunction, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
514			529
515	-	cret := xDBusConnectionAddFilter(x.GoPointer(), glib.NewCallback(FilterFunctionVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))	530	+	var FilterFunctionVarRef uintptr
			531	+	if FilterFunctionVar != nil {
			532	+	FilterFunctionVarPtr := uintptr(unsafe.Pointer(FilterFunctionVar))
			533	+	if cbRefPtr, ok := glib.GetCallback(FilterFunctionVarPtr); ok {
			534	+	FilterFunctionVarRef = cbRefPtr
			535	+	} else {
			536	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool, arg3 uintptr) uintptr {
			537	+	cbFn := *FilterFunctionVar
			538	+	return cbFn(arg0, arg1, arg2, arg3)
			539	+	}
			540	+	FilterFunctionVarRef = purego.NewCallback(fcb)
			541	+	glib.SaveCallback(FilterFunctionVarPtr, FilterFunctionVarRef)
			542	+	}
			543	+	}
			544	+
			545	+	var UserDataFreeFuncVarRef uintptr
			546	+	if UserDataFreeFuncVar != nil {
			547	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			548	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			549	+	UserDataFreeFuncVarRef = cbRefPtr
			550	+	} else {
			551	+	fcb := func(arg0 uintptr) {
			552	+	cbFn := *UserDataFreeFuncVar
			553	+	cbFn(arg0)
			554	+	}
			555	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			556	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			557	+	}
			558	+	}
			559	+
			560	+	cret := xDBusConnectionAddFilter(x.GoPointer(), FilterFunctionVarRef, UserDataVar, UserDataFreeFuncVarRef)
516		return cret	561		return cret
517		}	562		}
518			563
519	-	var xDBusConnectionCall func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, uintptr, uintptr)	564	+	var xDBusConnectionCall func(uintptr, uintptr, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, uintptr, uintptr)
520			565
521		// Asynchronously invokes the @method_name method on the	566		// Asynchronously invokes the @method_name method on the
522		// @interface_name D-Bus interface on the remote object at	567		// @interface_name D-Bus interface on the remote object at

@@ -565,9 +610,24 @@ var xDBusConnectionCall func(uintptr, string, string, string, string, *glib.Vari
565		//	610		//
566		// If @callback is %NULL then the D-Bus method call message will be sent with	611		// If @callback is %NULL then the D-Bus method call message will be sent with
567		// the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.	612		// the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
568	-	func (x DBusConnection) Call(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	613	+	func (x DBusConnection) Call(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
			614	+
			615	+	var CallbackVarRef uintptr
			616	+	if CallbackVar != nil {
			617	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			618	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			619	+	CallbackVarRef = cbRefPtr
			620	+	} else {
			621	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			622	+	cbFn := *CallbackVar
			623	+	cbFn(arg0, arg1, arg2)
			624	+	}
			625	+	CallbackVarRef = purego.NewCallback(fcb)
			626	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			627	+	}
			628	+	}
569			629
570	-	xDBusConnectionCall(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	630	+	xDBusConnectionCall(x.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
571			631
572		}	632		}
573			633

@@ -585,7 +645,7 @@ func (x DBusConnection) CallFinish(ResVar AsyncResult) (glib.Variant, error) {
585			645
586		}	646		}
587			647
588	-	var xDBusConnectionCallSync func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, *glib.Error) glib.Variant	648	+	var xDBusConnectionCallSync func(uintptr, uintptr, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, *glib.Error) glib.Variant
589			649
590		// Synchronously invokes the @method_name method on the	650		// Synchronously invokes the @method_name method on the
591		// @interface_name D-Bus interface on the remote object at	651		// @interface_name D-Bus interface on the remote object at

@@ -625,10 +685,10 @@ var xDBusConnectionCallSync func(uintptr, string, string, string, string, *glib.
625		// The calling thread is blocked until a reply is received. See	685		// The calling thread is blocked until a reply is received. See
626		// g_dbus_connection_call() for the asynchronous version of	686		// g_dbus_connection_call() for the asynchronous version of
627		// this method.	687		// this method.
628	-	func (x DBusConnection) CallSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar Cancellable) (*glib.Variant, error) {	688	+	func (x DBusConnection) CallSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar Cancellable) (glib.Variant, error) {
629		var cerr *glib.Error	689		var cerr *glib.Error
630			690
631	-	cret := xDBusConnectionCallSync(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), &cerr)	691	+	cret := xDBusConnectionCallSync(x.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), &cerr)
632		if cerr == nil {	692		if cerr == nil {
633		return cret, nil	693		return cret, nil
634		}	694		}

@@ -636,7 +696,7 @@ func (x *DBusConnection) CallSync(BusNameVar string, ObjectPathVar string, Inter
636			696
637		}	697		}
638			698
639	-	var xDBusConnectionCallWithUnixFdList func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, uintptr, uintptr, uintptr)	699	+	var xDBusConnectionCallWithUnixFdList func(uintptr, uintptr, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, uintptr, uintptr, uintptr)
640			700
641		// Like g_dbus_connection_call() but also takes a #GUnixFDList object.	701		// Like g_dbus_connection_call() but also takes a #GUnixFDList object.
642		//	702		//

@@ -653,9 +713,24 @@ var xDBusConnectionCallWithUnixFdList func(uintptr, string, string, string, stri
653		// value of type %G_VARIANT_TYPE_HANDLE in the body of the message.	713		// value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
654		//	714		//
655		// This method is only available on UNIX.	715		// This method is only available on UNIX.
656	-	func (x DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	716	+	func (x DBusConnection) CallWithUnixFdList(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
			717	+
			718	+	var CallbackVarRef uintptr
			719	+	if CallbackVar != nil {
			720	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			721	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			722	+	CallbackVarRef = cbRefPtr
			723	+	} else {
			724	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			725	+	cbFn := *CallbackVar
			726	+	cbFn(arg0, arg1, arg2)
			727	+	}
			728	+	CallbackVarRef = purego.NewCallback(fcb)
			729	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			730	+	}
			731	+	}
657			732
658	-	xDBusConnectionCallWithUnixFdList(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	733	+	xDBusConnectionCallWithUnixFdList(x.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
659			734
660		}	735		}
661			736

@@ -684,17 +759,17 @@ func (x DBusConnection) CallWithUnixFdListFinish(OutFdListVar *UnixFDList, Res
684			759
685		}	760		}
686			761
687	-	var xDBusConnectionCallWithUnixFdListSync func(uintptr, string, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, UnixFDList, uintptr, glib.Error) *glib.Variant	762	+	var xDBusConnectionCallWithUnixFdListSync func(uintptr, uintptr, string, string, string, glib.Variant, glib.VariantType, DBusCallFlags, int, uintptr, UnixFDList, uintptr, glib.Error) *glib.Variant
688			763
689		// Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.	764		// Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
690		// See g_dbus_connection_call_with_unix_fd_list() and	765		// See g_dbus_connection_call_with_unix_fd_list() and
691		// g_dbus_connection_call_with_unix_fd_list_finish() for more details.	766		// g_dbus_connection_call_with_unix_fd_list_finish() for more details.
692		//	767		//
693		// This method is only available on UNIX.	768		// This method is only available on UNIX.
694	-	func (x DBusConnection) CallWithUnixFdListSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar *UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {	769	+	func (x DBusConnection) CallWithUnixFdListSync(BusNameVar string, ObjectPathVar string, InterfaceNameVar string, MethodNameVar string, ParametersVar glib.Variant, ReplyTypeVar glib.VariantType, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar UnixFDList, OutFdListVar UnixFDList, CancellableVar Cancellable) (*glib.Variant, error) {
695		var cerr *glib.Error	770		var cerr *glib.Error
696			771
697	-	cret := xDBusConnectionCallWithUnixFdListSync(x.GoPointer(), BusNameVar, ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), OutFdListVar, CancellableVar.GoPointer(), &cerr)	772	+	cret := xDBusConnectionCallWithUnixFdListSync(x.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar, InterfaceNameVar, MethodNameVar, ParametersVar, ReplyTypeVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), OutFdListVar, CancellableVar.GoPointer(), &cerr)
698		if cerr == nil {	773		if cerr == nil {
699		return cret, nil	774		return cret, nil
700		}	775		}

@@ -730,7 +805,22 @@ var xDBusConnectionClose func(uintptr, uintptr, uintptr, uintptr)
730		// version.	805		// version.
731		func (x DBusConnection) Close(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	806		func (x DBusConnection) Close(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
732			807
733	-	xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	808	+	var CallbackVarRef uintptr
			809	+	if CallbackVar != nil {
			810	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			811	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			812	+	CallbackVarRef = cbRefPtr
			813	+	} else {
			814	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			815	+	cbFn := *CallbackVar
			816	+	cbFn(arg0, arg1, arg2)
			817	+	}
			818	+	CallbackVarRef = purego.NewCallback(fcb)
			819	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			820	+	}
			821	+	}
			822	+
			823	+	xDBusConnectionClose(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
734			824
735		}	825		}
736			826

@@ -765,7 +855,7 @@ func (x DBusConnection) CloseSync(CancellableVar Cancellable) (bool, error) {
765			855
766		}	856		}
767			857
768	-	var xDBusConnectionEmitSignal func(uintptr, string, string, string, string, glib.Variant, *glib.Error) bool	858	+	var xDBusConnectionEmitSignal func(uintptr, uintptr, string, string, string, glib.Variant, *glib.Error) bool
769			859
770		// Emits a signal.	860		// Emits a signal.
771		//	861		//

@@ -774,10 +864,10 @@ var xDBusConnectionEmitSignal func(uintptr, string, string, string, string, *gli
774		// This can only fail if @parameters is not compatible with the D-Bus protocol	864		// This can only fail if @parameters is not compatible with the D-Bus protocol
775		// (%G_IO_ERROR_INVALID_ARGUMENT), or if @connection has been closed	865		// (%G_IO_ERROR_INVALID_ARGUMENT), or if @connection has been closed
776		// (%G_IO_ERROR_CLOSED).	866		// (%G_IO_ERROR_CLOSED).
777	-	func (x DBusConnection) EmitSignal(DestinationBusNameVar string, ObjectPathVar string, InterfaceNameVar string, SignalNameVar string, ParametersVar glib.Variant) (bool, error) {	867	+	func (x DBusConnection) EmitSignal(DestinationBusNameVar string, ObjectPathVar string, InterfaceNameVar string, SignalNameVar string, ParametersVar *glib.Variant) (bool, error) {
778		var cerr *glib.Error	868		var cerr *glib.Error
779			869
780	-	cret := xDBusConnectionEmitSignal(x.GoPointer(), DestinationBusNameVar, ObjectPathVar, InterfaceNameVar, SignalNameVar, ParametersVar, &cerr)	870	+	cret := xDBusConnectionEmitSignal(x.GoPointer(), core.NullableStringToPtr(DestinationBusNameVar), ObjectPathVar, InterfaceNameVar, SignalNameVar, ParametersVar, &cerr)
781		if cerr == nil {	871		if cerr == nil {
782		return cret, nil	872		return cret, nil
783		}	873		}

@@ -866,7 +956,22 @@ var xDBusConnectionFlush func(uintptr, uintptr, uintptr, uintptr)
866		// version.	956		// version.
867		func (x DBusConnection) Flush(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	957		func (x DBusConnection) Flush(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
868			958
869	-	xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	959	+	var CallbackVarRef uintptr
			960	+	if CallbackVar != nil {
			961	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			962	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			963	+	CallbackVarRef = cbRefPtr
			964	+	} else {
			965	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			966	+	cbFn := *CallbackVar
			967	+	cbFn(arg0, arg1, arg2)
			968	+	}
			969	+	CallbackVarRef = purego.NewCallback(fcb)
			970	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			971	+	}
			972	+	}
			973	+
			974	+	xDBusConnectionFlush(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
870			975
871		}	976		}
872			977

@@ -1063,7 +1168,22 @@ var xDBusConnectionRegisterObject func(uintptr, string, DBusInterfaceInfo, DBu
1063		func (x DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar DBusInterfaceInfo, VtableVar DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) (uint, error) {	1168		func (x DBusConnection) RegisterObject(ObjectPathVar string, InterfaceInfoVar DBusInterfaceInfo, VtableVar DBusInterfaceVTable, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) (uint, error) {
1064		var cerr *glib.Error	1169		var cerr *glib.Error
1065			1170
1066	-	cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)	1171	+	var UserDataFreeFuncVarRef uintptr
			1172	+	if UserDataFreeFuncVar != nil {
			1173	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			1174	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			1175	+	UserDataFreeFuncVarRef = cbRefPtr
			1176	+	} else {
			1177	+	fcb := func(arg0 uintptr) {
			1178	+	cbFn := *UserDataFreeFuncVar
			1179	+	cbFn(arg0)
			1180	+	}
			1181	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			1182	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			1183	+	}
			1184	+	}
			1185	+
			1186	+	cret := xDBusConnectionRegisterObject(x.GoPointer(), ObjectPathVar, InterfaceInfoVar, VtableVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
1067		if cerr == nil {	1187		if cerr == nil {
1068		return cret, nil	1188		return cret, nil
1069		}	1189		}

@@ -1155,7 +1275,22 @@ var xDBusConnectionRegisterSubtree func(uintptr, string, *DBusSubtreeVTable, DBu
1155		func (x DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {	1275		func (x DBusConnection) RegisterSubtree(ObjectPathVar string, VtableVar DBusSubtreeVTable, FlagsVar DBusSubtreeFlags, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) (uint, error) {
1156		var cerr *glib.Error	1276		var cerr *glib.Error
1157			1277
1158	-	cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, glib.NewCallback(UserDataFreeFuncVar), &cerr)	1278	+	var UserDataFreeFuncVarRef uintptr
			1279	+	if UserDataFreeFuncVar != nil {
			1280	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			1281	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			1282	+	UserDataFreeFuncVarRef = cbRefPtr
			1283	+	} else {
			1284	+	fcb := func(arg0 uintptr) {
			1285	+	cbFn := *UserDataFreeFuncVar
			1286	+	cbFn(arg0)
			1287	+	}
			1288	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			1289	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			1290	+	}
			1291	+	}
			1292	+
			1293	+	cret := xDBusConnectionRegisterSubtree(x.GoPointer(), ObjectPathVar, VtableVar, FlagsVar, UserDataVar, UserDataFreeFuncVarRef, &cerr)
1159		if cerr == nil {	1294		if cerr == nil {
1160		return cret, nil	1295		return cret, nil
1161		}	1296		}

@@ -1248,7 +1383,22 @@ var xDBusConnectionSendMessageWithReply func(uintptr, uintptr, DBusSendMessageFl
1248		// UNIX file descriptors.	1383		// UNIX file descriptors.
1249		func (x DBusConnection) SendMessageWithReply(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	1384		func (x DBusConnection) SendMessageWithReply(MessageVar DBusMessage, FlagsVar DBusSendMessageFlags, TimeoutMsecVar int, OutSerialVar uint32, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1250			1385
1251	-	xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1386	+	var CallbackVarRef uintptr
			1387	+	if CallbackVar != nil {
			1388	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1389	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1390	+	CallbackVarRef = cbRefPtr
			1391	+	} else {
			1392	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1393	+	cbFn := *CallbackVar
			1394	+	cbFn(arg0, arg1, arg2)
			1395	+	}
			1396	+	CallbackVarRef = purego.NewCallback(fcb)
			1397	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1398	+	}
			1399	+	}
			1400	+
			1401	+	xDBusConnectionSendMessageWithReply(x.GoPointer(), MessageVar.GoPointer(), FlagsVar, TimeoutMsecVar, OutSerialVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1252			1402
1253		}	1403		}
1254			1404

@@ -1352,7 +1502,7 @@ func (x *DBusConnection) SetExitOnClose(ExitOnCloseVar bool) {
1352			1502
1353		}	1503		}
1354			1504
1355	-	var xDBusConnectionSignalSubscribe func(uintptr, string, string, string, string, string, DBusSignalFlags, uintptr, uintptr, uintptr) uint	1505	+	var xDBusConnectionSignalSubscribe func(uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, DBusSignalFlags, uintptr, uintptr, uintptr) uint
1356			1506
1357		// Subscribes to signals on @connection and invokes @callback whenever	1507		// Subscribes to signals on @connection and invokes @callback whenever
1358		// the signal is received. Note that @callback will be invoked in the	1508		// the signal is received. Note that @callback will be invoked in the

@@ -1403,9 +1553,39 @@ var xDBusConnectionSignalSubscribe func(uintptr, string, string, string, string,
1403		// to never be zero.	1553		// to never be zero.
1404		//	1554		//
1405		// This function can never fail.	1555		// This function can never fail.
1406	-	func (x DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {	1556	+	func (x DBusConnection) SignalSubscribe(SenderVar string, InterfaceNameVar string, MemberVar string, ObjectPathVar string, Arg0Var string, FlagsVar DBusSignalFlags, CallbackVar DBusSignalCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
			1557	+
			1558	+	var CallbackVarRef uintptr
			1559	+	if CallbackVar != nil {
			1560	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1561	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1562	+	CallbackVarRef = cbRefPtr
			1563	+	} else {
			1564	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 string, arg4 string, arg5 *glib.Variant, arg6 uintptr) {
			1565	+	cbFn := *CallbackVar
			1566	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
			1567	+	}
			1568	+	CallbackVarRef = purego.NewCallback(fcb)
			1569	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1570	+	}
			1571	+	}
1407			1572
1408	-	cret := xDBusConnectionSignalSubscribe(x.GoPointer(), SenderVar, InterfaceNameVar, MemberVar, ObjectPathVar, Arg0Var, FlagsVar, glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))	1573	+	var UserDataFreeFuncVarRef uintptr
			1574	+	if UserDataFreeFuncVar != nil {
			1575	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			1576	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			1577	+	UserDataFreeFuncVarRef = cbRefPtr
			1578	+	} else {
			1579	+	fcb := func(arg0 uintptr) {
			1580	+	cbFn := *UserDataFreeFuncVar
			1581	+	cbFn(arg0)
			1582	+	}
			1583	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			1584	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			1585	+	}
			1586	+	}
			1587	+
			1588	+	cret := xDBusConnectionSignalSubscribe(x.GoPointer(), core.NullableStringToPtr(SenderVar), core.NullableStringToPtr(InterfaceNameVar), core.NullableStringToPtr(MemberVar), core.NullableStringToPtr(ObjectPathVar), core.NullableStringToPtr(Arg0Var), FlagsVar, CallbackVarRef, UserDataVar, UserDataFreeFuncVarRef)
1409		return cret	1589		return cret
1410		}	1590		}
1411			1591

@@ -1504,7 +1684,7 @@ func (c *DBusConnection) SetGoPointer(ptr uintptr) {
1504		func (x *DBusConnection) SetPropertyAddress(value string) {	1684		func (x *DBusConnection) SetPropertyAddress(value string) {
1505		var v gobject.Value	1685		var v gobject.Value
1506		v.Init(gobject.TypeStringVal)	1686		v.Init(gobject.TypeStringVal)
1507	-	v.SetString(value)	1687	+	v.SetString(&value)
1508		x.SetProperty("address", &v)	1688		x.SetProperty("address", &v)
1509		}	1689		}
1510			1690

@@ -1569,7 +1749,7 @@ func (x *DBusConnection) GetPropertyExitOnClose() bool {
1569		func (x *DBusConnection) SetPropertyGuid(value string) {	1749		func (x *DBusConnection) SetPropertyGuid(value string) {
1570		var v gobject.Value	1750		var v gobject.Value
1571		v.Init(gobject.TypeStringVal)	1751		v.Init(gobject.TypeStringVal)
1572	-	v.SetString(value)	1752	+	v.SetString(&value)
1573		x.SetProperty("guid", &v)	1753		x.SetProperty("guid", &v)
1574		}	1754		}
1575			1755

@@ -1770,7 +1950,7 @@ func (x DBusConnection) Init(CancellableVar Cancellable) (bool, error) {
1770			1950
1771		}	1951		}
1772			1952
1773	-	var xDBusConnectionNew func(uintptr, string, DBusConnectionFlags, uintptr, uintptr, uintptr, uintptr)	1953	+	var xDBusConnectionNew func(uintptr, uintptr, DBusConnectionFlags, uintptr, uintptr, uintptr, uintptr)
1774			1954
1775		// Asynchronously sets up a D-Bus connection for exchanging D-Bus messages	1955		// Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
1776		// with the end represented by @stream.	1956		// with the end represented by @stream.

@@ -1792,9 +1972,24 @@ var xDBusConnectionNew func(uintptr, string, DBusConnectionFlags, uintptr, uintp
1792		// This is an asynchronous failable constructor. See	1972		// This is an asynchronous failable constructor. See
1793		// g_dbus_connection_new_sync() for the synchronous	1973		// g_dbus_connection_new_sync() for the synchronous
1794		// version.	1974		// version.
1795	-	func DBusConnectionNew(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1975	+	func DBusConnectionNew(StreamVar IOStream, GuidVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
			1976	+
			1977	+	var CallbackVarRef uintptr
			1978	+	if CallbackVar != nil {
			1979	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1980	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1981	+	CallbackVarRef = cbRefPtr
			1982	+	} else {
			1983	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1984	+	cbFn := *CallbackVar
			1985	+	cbFn(arg0, arg1, arg2)
			1986	+	}
			1987	+	CallbackVarRef = purego.NewCallback(fcb)
			1988	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1989	+	}
			1990	+	}
1796			1991
1797	-	xDBusConnectionNew(StreamVar.GoPointer(), GuidVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1992	+	xDBusConnectionNew(StreamVar.GoPointer(), core.NullableStringToPtr(GuidVar), FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1798			1993
1799		}	1994		}
1800			1995

@@ -1824,7 +2019,22 @@ var xDBusConnectionNewForAddress func(string, DBusConnectionFlags, uintptr, uint
1824		// version.	2019		// version.
1825		func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	2020		func DBusConnectionNewForAddress(AddressVar string, FlagsVar DBusConnectionFlags, ObserverVar DBusAuthObserver, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1826			2021
1827	-	xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	2022	+	var CallbackVarRef uintptr
			2023	+	if CallbackVar != nil {
			2024	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			2025	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			2026	+	CallbackVarRef = cbRefPtr
			2027	+	} else {
			2028	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			2029	+	cbFn := *CallbackVar
			2030	+	cbFn(arg0, arg1, arg2)
			2031	+	}
			2032	+	CallbackVarRef = purego.NewCallback(fcb)
			2033	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			2034	+	}
			2035	+	}
			2036	+
			2037	+	xDBusConnectionNewForAddress(AddressVar, FlagsVar, ObserverVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1828			2038
1829		}	2039		}
1830			2040

M v4/gio/gdbusmenumodel.go +3 -3


@@ -37,7 +37,7 @@ func (c *DBusMenuModel) SetGoPointer(ptr uintptr) {
37		c.Ptr = ptr	37		c.Ptr = ptr
38		}	38		}
39			39
40	-	var xDBusMenuModelGet func(uintptr, string, string) uintptr	40	+	var xDBusMenuModelGet func(uintptr, uintptr, string) uintptr
41			41
42		// Obtains a #GDBusMenuModel for the menu model which is exported	42		// Obtains a #GDBusMenuModel for the menu model which is exported
43		// at the given @bus_name and @object_path.	43		// at the given @bus_name and @object_path.

@@ -47,10 +47,10 @@ var xDBusMenuModelGet func(uintptr, string, string) uintptr
47		// with respect to this context. All calls on the returned menu model	47		// with respect to this context. All calls on the returned menu model
48		// (and linked models) must also originate from this same context, with	48		// (and linked models) must also originate from this same context, with
49		// the thread default main context unchanged.	49		// the thread default main context unchanged.
50	-	func DBusMenuModelGet(ConnectionVar DBusConnection, BusNameVar string, ObjectPathVar string) DBusMenuModel {	50	+	func DBusMenuModelGet(ConnectionVar DBusConnection, BusNameVar string, ObjectPathVar string) *DBusMenuModel {
51		var cls *DBusMenuModel	51		var cls *DBusMenuModel
52			52
53	-	cret := xDBusMenuModelGet(ConnectionVar.GoPointer(), BusNameVar, ObjectPathVar)	53	+	cret := xDBusMenuModelGet(ConnectionVar.GoPointer(), core.NullableStringToPtr(BusNameVar), ObjectPathVar)
54			54
55		if cret == 0 {	55		if cret == 0 {
56		return nil	56		return nil

M v4/gio/gdbusmessage.go +21 -21


@@ -69,13 +69,13 @@ func NewDBusMessageFromBlob(BlobVar []byte, BlobLenVar uint, CapabilitiesVar DBu
69			69
70		}	70		}
71			71
72	-	var xNewDBusMessageMethodCall func(string, string, string, string) uintptr	72	+	var xNewDBusMessageMethodCall func(uintptr, string, uintptr, string) uintptr
73			73
74		// Creates a new #GDBusMessage for a method call.	74		// Creates a new #GDBusMessage for a method call.
75	-	func NewDBusMessageMethodCall(NameVar string, PathVar string, InterfaceVar string, MethodVar string) *DBusMessage {	75	+	func NewDBusMessageMethodCall(NameVar string, PathVar string, InterfaceVar string, MethodVar string) *DBusMessage {
76		var cls *DBusMessage	76		var cls *DBusMessage
77			77
78	-	cret := xNewDBusMessageMethodCall(NameVar, PathVar, InterfaceVar, MethodVar)	78	+	cret := xNewDBusMessageMethodCall(core.NullableStringToPtr(NameVar), PathVar, core.NullableStringToPtr(InterfaceVar), MethodVar)
79			79
80		if cret == 0 {	80		if cret == 0 {
81		return nil	81		return nil

@@ -478,12 +478,12 @@ func (x *DBusMessage) SetByteOrder(ByteOrderVar DBusMessageByteOrder) {
478			478
479		}	479		}
480			480
481	-	var xDBusMessageSetDestination func(uintptr, string)	481	+	var xDBusMessageSetDestination func(uintptr, uintptr)
482			482
483		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.	483		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
484	-	func (x *DBusMessage) SetDestination(ValueVar string) {	484	+	func (x DBusMessage) SetDestination(ValueVar string) {
485			485
486	-	xDBusMessageSetDestination(x.GoPointer(), ValueVar)	486	+	xDBusMessageSetDestination(x.GoPointer(), core.NullableStringToPtr(ValueVar))
487			487
488		}	488		}
489			489

@@ -516,21 +516,21 @@ func (x *DBusMessage) SetHeader(HeaderFieldVar DBusMessageHeaderField, ValueVar
516			516
517		}	517		}
518			518
519	-	var xDBusMessageSetInterface func(uintptr, string)	519	+	var xDBusMessageSetInterface func(uintptr, uintptr)
520			520
521		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.	521		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
522	-	func (x *DBusMessage) SetInterface(ValueVar string) {	522	+	func (x DBusMessage) SetInterface(ValueVar string) {
523			523
524	-	xDBusMessageSetInterface(x.GoPointer(), ValueVar)	524	+	xDBusMessageSetInterface(x.GoPointer(), core.NullableStringToPtr(ValueVar))
525			525
526		}	526		}
527			527
528	-	var xDBusMessageSetMember func(uintptr, string)	528	+	var xDBusMessageSetMember func(uintptr, uintptr)
529			529
530		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.	530		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
531	-	func (x *DBusMessage) SetMember(ValueVar string) {	531	+	func (x DBusMessage) SetMember(ValueVar string) {
532			532
533	-	xDBusMessageSetMember(x.GoPointer(), ValueVar)	533	+	xDBusMessageSetMember(x.GoPointer(), core.NullableStringToPtr(ValueVar))
534			534
535		}	535		}
536			536

@@ -552,12 +552,12 @@ func (x *DBusMessage) SetNumUnixFds(ValueVar uint32) {
552			552
553		}	553		}
554			554
555	-	var xDBusMessageSetPath func(uintptr, string)	555	+	var xDBusMessageSetPath func(uintptr, uintptr)
556			556
557		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.	557		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
558	-	func (x *DBusMessage) SetPath(ValueVar string) {	558	+	func (x DBusMessage) SetPath(ValueVar string) {
559			559
560	-	xDBusMessageSetPath(x.GoPointer(), ValueVar)	560	+	xDBusMessageSetPath(x.GoPointer(), core.NullableStringToPtr(ValueVar))
561			561
562		}	562		}
563			563

@@ -570,12 +570,12 @@ func (x *DBusMessage) SetReplySerial(ValueVar uint32) {
570			570
571		}	571		}
572			572
573	-	var xDBusMessageSetSender func(uintptr, string)	573	+	var xDBusMessageSetSender func(uintptr, uintptr)
574			574
575		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.	575		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
576	-	func (x *DBusMessage) SetSender(ValueVar string) {	576	+	func (x DBusMessage) SetSender(ValueVar string) {
577			577
578	-	xDBusMessageSetSender(x.GoPointer(), ValueVar)	578	+	xDBusMessageSetSender(x.GoPointer(), core.NullableStringToPtr(ValueVar))
579			579
580		}	580		}
581			581

@@ -591,12 +591,12 @@ func (x *DBusMessage) SetSerial(SerialVar uint32) {
591			591
592		}	592		}
593			593
594	-	var xDBusMessageSetSignature func(uintptr, string)	594	+	var xDBusMessageSetSignature func(uintptr, uintptr)
595			595
596		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.	596		// Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
597	-	func (x *DBusMessage) SetSignature(ValueVar string) {	597	+	func (x DBusMessage) SetSignature(ValueVar string) {
598			598
599	-	xDBusMessageSetSignature(x.GoPointer(), ValueVar)	599	+	xDBusMessageSetSignature(x.GoPointer(), core.NullableStringToPtr(ValueVar))
600			600
601		}	601		}
602			602

M v4/gio/gdbusnameowning.go +109 -2


@@ -2,6 +2,8 @@
2		package gio	2		package gio
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -71,7 +73,67 @@ var xBusOwnName func(BusType, string, BusNameOwnerFlags, uintptr, uintptr, uintp
71		// unregister the objects (if any) in @name_lost_handler.	73		// unregister the objects (if any) in @name_lost_handler.
72		func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar BusAcquiredCallback, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	74		func BusOwnName(BusTypeVar BusType, NameVar string, FlagsVar BusNameOwnerFlags, BusAcquiredHandlerVar BusAcquiredCallback, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
73			75
74	-	cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, glib.NewCallbackNullable(BusAcquiredHandlerVar), glib.NewCallbackNullable(NameAcquiredHandlerVar), glib.NewCallbackNullable(NameLostHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))	76	+	var BusAcquiredHandlerVarRef uintptr
			77	+	if BusAcquiredHandlerVar != nil {
			78	+	BusAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(BusAcquiredHandlerVar))
			79	+	if cbRefPtr, ok := glib.GetCallback(BusAcquiredHandlerVarPtr); ok {
			80	+	BusAcquiredHandlerVarRef = cbRefPtr
			81	+	} else {
			82	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			83	+	cbFn := *BusAcquiredHandlerVar
			84	+	cbFn(arg0, arg1, arg2)
			85	+	}
			86	+	BusAcquiredHandlerVarRef = purego.NewCallback(fcb)
			87	+	glib.SaveCallback(BusAcquiredHandlerVarPtr, BusAcquiredHandlerVarRef)
			88	+	}
			89	+	}
			90	+
			91	+	var NameAcquiredHandlerVarRef uintptr
			92	+	if NameAcquiredHandlerVar != nil {
			93	+	NameAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(NameAcquiredHandlerVar))
			94	+	if cbRefPtr, ok := glib.GetCallback(NameAcquiredHandlerVarPtr); ok {
			95	+	NameAcquiredHandlerVarRef = cbRefPtr
			96	+	} else {
			97	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			98	+	cbFn := *NameAcquiredHandlerVar
			99	+	cbFn(arg0, arg1, arg2)
			100	+	}
			101	+	NameAcquiredHandlerVarRef = purego.NewCallback(fcb)
			102	+	glib.SaveCallback(NameAcquiredHandlerVarPtr, NameAcquiredHandlerVarRef)
			103	+	}
			104	+	}
			105	+
			106	+	var NameLostHandlerVarRef uintptr
			107	+	if NameLostHandlerVar != nil {
			108	+	NameLostHandlerVarPtr := uintptr(unsafe.Pointer(NameLostHandlerVar))
			109	+	if cbRefPtr, ok := glib.GetCallback(NameLostHandlerVarPtr); ok {
			110	+	NameLostHandlerVarRef = cbRefPtr
			111	+	} else {
			112	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			113	+	cbFn := *NameLostHandlerVar
			114	+	cbFn(arg0, arg1, arg2)
			115	+	}
			116	+	NameLostHandlerVarRef = purego.NewCallback(fcb)
			117	+	glib.SaveCallback(NameLostHandlerVarPtr, NameLostHandlerVarRef)
			118	+	}
			119	+	}
			120	+
			121	+	var UserDataFreeFuncVarRef uintptr
			122	+	if UserDataFreeFuncVar != nil {
			123	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			124	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			125	+	UserDataFreeFuncVarRef = cbRefPtr
			126	+	} else {
			127	+	fcb := func(arg0 uintptr) {
			128	+	cbFn := *UserDataFreeFuncVar
			129	+	cbFn(arg0)
			130	+	}
			131	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			132	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			133	+	}
			134	+	}
			135	+
			136	+	cret := xBusOwnName(BusTypeVar, NameVar, FlagsVar, BusAcquiredHandlerVarRef, NameAcquiredHandlerVarRef, NameLostHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
75		return cret	137		return cret
76		}	138		}
77			139

@@ -81,7 +143,52 @@ var xBusOwnNameOnConnection func(uintptr, string, BusNameOwnerFlags, uintptr, ui
81		// of a [enum@Gio.BusType].	143		// of a [enum@Gio.BusType].
82		func BusOwnNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	144		func BusOwnNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameOwnerFlags, NameAcquiredHandlerVar BusNameAcquiredCallback, NameLostHandlerVar BusNameLostCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
83			145
84	-	cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallbackNullable(NameAcquiredHandlerVar), glib.NewCallbackNullable(NameLostHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))	146	+	var NameAcquiredHandlerVarRef uintptr
			147	+	if NameAcquiredHandlerVar != nil {
			148	+	NameAcquiredHandlerVarPtr := uintptr(unsafe.Pointer(NameAcquiredHandlerVar))
			149	+	if cbRefPtr, ok := glib.GetCallback(NameAcquiredHandlerVarPtr); ok {
			150	+	NameAcquiredHandlerVarRef = cbRefPtr
			151	+	} else {
			152	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			153	+	cbFn := *NameAcquiredHandlerVar
			154	+	cbFn(arg0, arg1, arg2)
			155	+	}
			156	+	NameAcquiredHandlerVarRef = purego.NewCallback(fcb)
			157	+	glib.SaveCallback(NameAcquiredHandlerVarPtr, NameAcquiredHandlerVarRef)
			158	+	}
			159	+	}
			160	+
			161	+	var NameLostHandlerVarRef uintptr
			162	+	if NameLostHandlerVar != nil {
			163	+	NameLostHandlerVarPtr := uintptr(unsafe.Pointer(NameLostHandlerVar))
			164	+	if cbRefPtr, ok := glib.GetCallback(NameLostHandlerVarPtr); ok {
			165	+	NameLostHandlerVarRef = cbRefPtr
			166	+	} else {
			167	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			168	+	cbFn := *NameLostHandlerVar
			169	+	cbFn(arg0, arg1, arg2)
			170	+	}
			171	+	NameLostHandlerVarRef = purego.NewCallback(fcb)
			172	+	glib.SaveCallback(NameLostHandlerVarPtr, NameLostHandlerVarRef)
			173	+	}
			174	+	}
			175	+
			176	+	var UserDataFreeFuncVarRef uintptr
			177	+	if UserDataFreeFuncVar != nil {
			178	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			179	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			180	+	UserDataFreeFuncVarRef = cbRefPtr
			181	+	} else {
			182	+	fcb := func(arg0 uintptr) {
			183	+	cbFn := *UserDataFreeFuncVar
			184	+	cbFn(arg0)
			185	+	}
			186	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			187	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			188	+	}
			189	+	}
			190	+
			191	+	cret := xBusOwnNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, NameAcquiredHandlerVarRef, NameLostHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
85		return cret	192		return cret
86		}	193		}
87			194

M v4/gio/gdbusnamewatching.go +94 -2


@@ -2,6 +2,8 @@
2		package gio	2		package gio
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -67,7 +69,52 @@ var xBusWatchName func(BusType, string, BusNameWatcherFlags, uintptr, uintptr, u
67		// @name_vanished_handler.	69		// @name_vanished_handler.
68		func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {	70		func BusWatchName(BusTypeVar BusType, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) uint {
69			71
70	-	cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, glib.NewCallbackNullable(NameAppearedHandlerVar), glib.NewCallbackNullable(NameVanishedHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))	72	+	var NameAppearedHandlerVarRef uintptr
			73	+	if NameAppearedHandlerVar != nil {
			74	+	NameAppearedHandlerVarPtr := uintptr(unsafe.Pointer(NameAppearedHandlerVar))
			75	+	if cbRefPtr, ok := glib.GetCallback(NameAppearedHandlerVarPtr); ok {
			76	+	NameAppearedHandlerVarRef = cbRefPtr
			77	+	} else {
			78	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) {
			79	+	cbFn := *NameAppearedHandlerVar
			80	+	cbFn(arg0, arg1, arg2, arg3)
			81	+	}
			82	+	NameAppearedHandlerVarRef = purego.NewCallback(fcb)
			83	+	glib.SaveCallback(NameAppearedHandlerVarPtr, NameAppearedHandlerVarRef)
			84	+	}
			85	+	}
			86	+
			87	+	var NameVanishedHandlerVarRef uintptr
			88	+	if NameVanishedHandlerVar != nil {
			89	+	NameVanishedHandlerVarPtr := uintptr(unsafe.Pointer(NameVanishedHandlerVar))
			90	+	if cbRefPtr, ok := glib.GetCallback(NameVanishedHandlerVarPtr); ok {
			91	+	NameVanishedHandlerVarRef = cbRefPtr
			92	+	} else {
			93	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			94	+	cbFn := *NameVanishedHandlerVar
			95	+	cbFn(arg0, arg1, arg2)
			96	+	}
			97	+	NameVanishedHandlerVarRef = purego.NewCallback(fcb)
			98	+	glib.SaveCallback(NameVanishedHandlerVarPtr, NameVanishedHandlerVarRef)
			99	+	}
			100	+	}
			101	+
			102	+	var UserDataFreeFuncVarRef uintptr
			103	+	if UserDataFreeFuncVar != nil {
			104	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			105	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			106	+	UserDataFreeFuncVarRef = cbRefPtr
			107	+	} else {
			108	+	fcb := func(arg0 uintptr) {
			109	+	cbFn := *UserDataFreeFuncVar
			110	+	cbFn(arg0)
			111	+	}
			112	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			113	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			114	+	}
			115	+	}
			116	+
			117	+	cret := xBusWatchName(BusTypeVar, NameVar, FlagsVar, NameAppearedHandlerVarRef, NameVanishedHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
71		return cret	118		return cret
72		}	119		}
73			120

@@ -77,7 +124,52 @@ var xBusWatchNameOnConnection func(uintptr, string, BusNameWatcherFlags, uintptr
77		// #GBusType.	124		// #GBusType.
78		func BusWatchNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {	125		func BusWatchNameOnConnection(ConnectionVar DBusConnection, NameVar string, FlagsVar BusNameWatcherFlags, NameAppearedHandlerVar BusNameAppearedCallback, NameVanishedHandlerVar BusNameVanishedCallback, UserDataVar uintptr, UserDataFreeFuncVar glib.DestroyNotify) uint {
79			126
80	-	cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, glib.NewCallbackNullable(NameAppearedHandlerVar), glib.NewCallbackNullable(NameVanishedHandlerVar), UserDataVar, glib.NewCallbackNullable(UserDataFreeFuncVar))	127	+	var NameAppearedHandlerVarRef uintptr
			128	+	if NameAppearedHandlerVar != nil {
			129	+	NameAppearedHandlerVarPtr := uintptr(unsafe.Pointer(NameAppearedHandlerVar))
			130	+	if cbRefPtr, ok := glib.GetCallback(NameAppearedHandlerVarPtr); ok {
			131	+	NameAppearedHandlerVarRef = cbRefPtr
			132	+	} else {
			133	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) {
			134	+	cbFn := *NameAppearedHandlerVar
			135	+	cbFn(arg0, arg1, arg2, arg3)
			136	+	}
			137	+	NameAppearedHandlerVarRef = purego.NewCallback(fcb)
			138	+	glib.SaveCallback(NameAppearedHandlerVarPtr, NameAppearedHandlerVarRef)
			139	+	}
			140	+	}
			141	+
			142	+	var NameVanishedHandlerVarRef uintptr
			143	+	if NameVanishedHandlerVar != nil {
			144	+	NameVanishedHandlerVarPtr := uintptr(unsafe.Pointer(NameVanishedHandlerVar))
			145	+	if cbRefPtr, ok := glib.GetCallback(NameVanishedHandlerVarPtr); ok {
			146	+	NameVanishedHandlerVarRef = cbRefPtr
			147	+	} else {
			148	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) {
			149	+	cbFn := *NameVanishedHandlerVar
			150	+	cbFn(arg0, arg1, arg2)
			151	+	}
			152	+	NameVanishedHandlerVarRef = purego.NewCallback(fcb)
			153	+	glib.SaveCallback(NameVanishedHandlerVarPtr, NameVanishedHandlerVarRef)
			154	+	}
			155	+	}
			156	+
			157	+	var UserDataFreeFuncVarRef uintptr
			158	+	if UserDataFreeFuncVar != nil {
			159	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			160	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			161	+	UserDataFreeFuncVarRef = cbRefPtr
			162	+	} else {
			163	+	fcb := func(arg0 uintptr) {
			164	+	cbFn := *UserDataFreeFuncVar
			165	+	cbFn(arg0)
			166	+	}
			167	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			168	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			169	+	}
			170	+	}
			171	+
			172	+	cret := xBusWatchNameOnConnection(ConnectionVar.GoPointer(), NameVar, FlagsVar, NameAppearedHandlerVarRef, NameVanishedHandlerVarRef, UserDataVar, UserDataFreeFuncVarRef)
81		return cret	173		return cret
82		}	174		}
83			175

M v4/gio/gdbusobjectmanagerclient.go +158 -8


@@ -235,7 +235,37 @@ func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjec
235		var cls *DBusObjectManagerClient	235		var cls *DBusObjectManagerClient
236		var cerr *glib.Error	236		var cerr *glib.Error
237			237
238	-	cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)	238	+	var GetProxyTypeFuncVarRef uintptr
			239	+	if GetProxyTypeFuncVar != nil {
			240	+	GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
			241	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
			242	+	GetProxyTypeFuncVarRef = cbRefPtr
			243	+	} else {
			244	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
			245	+	cbFn := *GetProxyTypeFuncVar
			246	+	return cbFn(arg0, arg1, arg2, arg3)
			247	+	}
			248	+	GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
			249	+	glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
			250	+	}
			251	+	}
			252	+
			253	+	var GetProxyTypeDestroyNotifyVarRef uintptr
			254	+	if GetProxyTypeDestroyNotifyVar != nil {
			255	+	GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
			256	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
			257	+	GetProxyTypeDestroyNotifyVarRef = cbRefPtr
			258	+	} else {
			259	+	fcb := func(arg0 uintptr) {
			260	+	cbFn := *GetProxyTypeDestroyNotifyVar
			261	+	cbFn(arg0)
			262	+	}
			263	+	GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
			264	+	glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
			265	+	}
			266	+	}
			267	+
			268	+	cret := xNewDBusObjectManagerClientForBusSync(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), &cerr)
239			269
240		if cret == 0 {	270		if cret == 0 {
241		return nil, cerr	271		return nil, cerr

@@ -249,18 +279,48 @@ func NewDBusObjectManagerClientForBusSync(BusTypeVar BusType, FlagsVar DBusObjec
249			279
250		}	280		}
251			281
252	-	var xNewDBusObjectManagerClientSync func(uintptr, DBusObjectManagerClientFlags, string, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr	282	+	var xNewDBusObjectManagerClientSync func(uintptr, DBusObjectManagerClientFlags, uintptr, string, uintptr, uintptr, uintptr, uintptr, **glib.Error) uintptr
253			283
254		// Creates a new #GDBusObjectManagerClient object.	284		// Creates a new #GDBusObjectManagerClient object.
255		//	285		//
256		// This is a synchronous failable constructor - the calling thread is	286		// This is a synchronous failable constructor - the calling thread is
257		// blocked until a reply is received. See g_dbus_object_manager_client_new()	287		// blocked until a reply is received. See g_dbus_object_manager_client_new()
258		// for the asynchronous version.	288		// for the asynchronous version.
259	-	func NewDBusObjectManagerClientSync(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (*DBusObjectManagerClient, error) {	289	+	func NewDBusObjectManagerClientSync(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable) (DBusObjectManagerClient, error) {
260		var cls *DBusObjectManagerClient	290		var cls *DBusObjectManagerClient
261		var cerr *glib.Error	291		var cerr *glib.Error
262			292
263	-	cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), &cerr)	293	+	var GetProxyTypeFuncVarRef uintptr
			294	+	if GetProxyTypeFuncVar != nil {
			295	+	GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
			296	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
			297	+	GetProxyTypeFuncVarRef = cbRefPtr
			298	+	} else {
			299	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
			300	+	cbFn := *GetProxyTypeFuncVar
			301	+	return cbFn(arg0, arg1, arg2, arg3)
			302	+	}
			303	+	GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
			304	+	glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
			305	+	}
			306	+	}
			307	+
			308	+	var GetProxyTypeDestroyNotifyVarRef uintptr
			309	+	if GetProxyTypeDestroyNotifyVar != nil {
			310	+	GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
			311	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
			312	+	GetProxyTypeDestroyNotifyVarRef = cbRefPtr
			313	+	} else {
			314	+	fcb := func(arg0 uintptr) {
			315	+	cbFn := *GetProxyTypeDestroyNotifyVar
			316	+	cbFn(arg0)
			317	+	}
			318	+	GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
			319	+	glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
			320	+	}
			321	+	}
			322	+
			323	+	cret := xNewDBusObjectManagerClientSync(ConnectionVar.GoPointer(), FlagsVar, core.NullableStringToPtr(NameVar), ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), &cerr)
264			324
265		if cret == 0 {	325		if cret == 0 {
266		return nil, cerr	326		return nil, cerr

@@ -391,7 +451,7 @@ func (x *DBusObjectManagerClient) GetPropertyGetProxyTypeUserData() uintptr {
391		func (x *DBusObjectManagerClient) SetPropertyName(value string) {	451		func (x *DBusObjectManagerClient) SetPropertyName(value string) {
392		var v gobject.Value	452		var v gobject.Value
393		v.Init(gobject.TypeStringVal)	453		v.Init(gobject.TypeStringVal)
394	-	v.SetString(value)	454	+	v.SetString(&value)
395		x.SetProperty("name", &v)	455		x.SetProperty("name", &v)
396		}	456		}
397			457

@@ -418,7 +478,7 @@ func (x *DBusObjectManagerClient) GetPropertyNameOwner() string {
418		func (x *DBusObjectManagerClient) SetPropertyObjectPath(value string) {	478		func (x *DBusObjectManagerClient) SetPropertyObjectPath(value string) {
419		var v gobject.Value	479		var v gobject.Value
420		v.Init(gobject.TypeStringVal)	480		v.Init(gobject.TypeStringVal)
421	-	v.SetString(value)	481	+	v.SetString(&value)
422		x.SetProperty("object-path", &v)	482		x.SetProperty("object-path", &v)
423		}	483		}
424			484

@@ -666,7 +726,52 @@ var xDBusObjectManagerClientNew func(uintptr, DBusObjectManagerClientFlags, stri
666		// g_dbus_object_manager_client_new_sync() for the synchronous version.	726		// g_dbus_object_manager_client_new_sync() for the synchronous version.
667		func DBusObjectManagerClientNew(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	727		func DBusObjectManagerClientNew(ConnectionVar DBusConnection, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
668			728
669	-	xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	729	+	var GetProxyTypeFuncVarRef uintptr
			730	+	if GetProxyTypeFuncVar != nil {
			731	+	GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
			732	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
			733	+	GetProxyTypeFuncVarRef = cbRefPtr
			734	+	} else {
			735	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
			736	+	cbFn := *GetProxyTypeFuncVar
			737	+	return cbFn(arg0, arg1, arg2, arg3)
			738	+	}
			739	+	GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
			740	+	glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
			741	+	}
			742	+	}
			743	+
			744	+	var GetProxyTypeDestroyNotifyVarRef uintptr
			745	+	if GetProxyTypeDestroyNotifyVar != nil {
			746	+	GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
			747	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
			748	+	GetProxyTypeDestroyNotifyVarRef = cbRefPtr
			749	+	} else {
			750	+	fcb := func(arg0 uintptr) {
			751	+	cbFn := *GetProxyTypeDestroyNotifyVar
			752	+	cbFn(arg0)
			753	+	}
			754	+	GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
			755	+	glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
			756	+	}
			757	+	}
			758	+
			759	+	var CallbackVarRef uintptr
			760	+	if CallbackVar != nil {
			761	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			762	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			763	+	CallbackVarRef = cbRefPtr
			764	+	} else {
			765	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			766	+	cbFn := *CallbackVar
			767	+	cbFn(arg0, arg1, arg2)
			768	+	}
			769	+	CallbackVarRef = purego.NewCallback(fcb)
			770	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			771	+	}
			772	+	}
			773	+
			774	+	xDBusObjectManagerClientNew(ConnectionVar.GoPointer(), FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
670			775
671		}	776		}
672			777

@@ -683,7 +788,52 @@ var xDBusObjectManagerClientNewForBus func(BusType, DBusObjectManagerClientFlags
683		// g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.	788		// g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
684		func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	789		func DBusObjectManagerClientNewForBus(BusTypeVar BusType, FlagsVar DBusObjectManagerClientFlags, NameVar string, ObjectPathVar string, GetProxyTypeFuncVar DBusProxyTypeFunc, GetProxyTypeUserDataVar uintptr, GetProxyTypeDestroyNotifyVar glib.DestroyNotify, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
685			790
686	-	xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, glib.NewCallbackNullable(GetProxyTypeFuncVar), GetProxyTypeUserDataVar, glib.NewCallbackNullable(GetProxyTypeDestroyNotifyVar), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	791	+	var GetProxyTypeFuncVarRef uintptr
			792	+	if GetProxyTypeFuncVar != nil {
			793	+	GetProxyTypeFuncVarPtr := uintptr(unsafe.Pointer(GetProxyTypeFuncVar))
			794	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeFuncVarPtr); ok {
			795	+	GetProxyTypeFuncVarRef = cbRefPtr
			796	+	} else {
			797	+	fcb := func(arg0 uintptr, arg1 string, arg2 string, arg3 uintptr) types.GType {
			798	+	cbFn := *GetProxyTypeFuncVar
			799	+	return cbFn(arg0, arg1, arg2, arg3)
			800	+	}
			801	+	GetProxyTypeFuncVarRef = purego.NewCallback(fcb)
			802	+	glib.SaveCallback(GetProxyTypeFuncVarPtr, GetProxyTypeFuncVarRef)
			803	+	}
			804	+	}
			805	+
			806	+	var GetProxyTypeDestroyNotifyVarRef uintptr
			807	+	if GetProxyTypeDestroyNotifyVar != nil {
			808	+	GetProxyTypeDestroyNotifyVarPtr := uintptr(unsafe.Pointer(GetProxyTypeDestroyNotifyVar))
			809	+	if cbRefPtr, ok := glib.GetCallback(GetProxyTypeDestroyNotifyVarPtr); ok {
			810	+	GetProxyTypeDestroyNotifyVarRef = cbRefPtr
			811	+	} else {
			812	+	fcb := func(arg0 uintptr) {
			813	+	cbFn := *GetProxyTypeDestroyNotifyVar
			814	+	cbFn(arg0)
			815	+	}
			816	+	GetProxyTypeDestroyNotifyVarRef = purego.NewCallback(fcb)
			817	+	glib.SaveCallback(GetProxyTypeDestroyNotifyVarPtr, GetProxyTypeDestroyNotifyVarRef)
			818	+	}
			819	+	}
			820	+
			821	+	var CallbackVarRef uintptr
			822	+	if CallbackVar != nil {
			823	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			824	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			825	+	CallbackVarRef = cbRefPtr
			826	+	} else {
			827	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			828	+	cbFn := *CallbackVar
			829	+	cbFn(arg0, arg1, arg2)
			830	+	}
			831	+	CallbackVarRef = purego.NewCallback(fcb)
			832	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			833	+	}
			834	+	}
			835	+
			836	+	xDBusObjectManagerClientNewForBus(BusTypeVar, FlagsVar, NameVar, ObjectPathVar, GetProxyTypeFuncVarRef, GetProxyTypeUserDataVar, GetProxyTypeDestroyNotifyVarRef, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
687			837
688		}	838		}
689			839

M v4/gio/gdbusobjectmanagerserver.go +1 -1


@@ -186,7 +186,7 @@ func (c *DBusObjectManagerServer) SetGoPointer(ptr uintptr) {
186		func (x *DBusObjectManagerServer) SetPropertyObjectPath(value string) {	186		func (x *DBusObjectManagerServer) SetPropertyObjectPath(value string) {
187		var v gobject.Value	187		var v gobject.Value
188		v.Init(gobject.TypeStringVal)	188		v.Init(gobject.TypeStringVal)
189	-	v.SetString(value)	189	+	v.SetString(&value)
190		x.SetProperty("object-path", &v)	190		x.SetProperty("object-path", &v)
191		}	191		}
192			192

M v4/gio/gdbusobjectproxy.go +1 -1


@@ -103,7 +103,7 @@ func (c *DBusObjectProxy) SetGoPointer(ptr uintptr) {
103		func (x *DBusObjectProxy) SetPropertyGObjectPath(value string) {	103		func (x *DBusObjectProxy) SetPropertyGObjectPath(value string) {
104		var v gobject.Value	104		var v gobject.Value
105		v.Init(gobject.TypeStringVal)	105		v.Init(gobject.TypeStringVal)
106	-	v.SetString(value)	106	+	v.SetString(&value)
107		x.SetProperty("g-object-path", &v)	107		x.SetProperty("g-object-path", &v)
108		}	108		}
109			109

M v4/gio/gdbusobjectskeleton.go +1 -1


@@ -169,7 +169,7 @@ func (c *DBusObjectSkeleton) SetGoPointer(ptr uintptr) {
169		func (x *DBusObjectSkeleton) SetPropertyGObjectPath(value string) {	169		func (x *DBusObjectSkeleton) SetPropertyGObjectPath(value string) {
170		var v gobject.Value	170		var v gobject.Value
171		v.Init(gobject.TypeStringVal)	171		v.Init(gobject.TypeStringVal)
172	-	v.SetString(value)	172	+	v.SetString(&value)
173		x.SetProperty("g-object-path", &v)	173		x.SetProperty("g-object-path", &v)
174		}	174		}
175			175

M v4/gio/gdbusproxy.go +95 -12

 package gio
 import (
+	"fmt"
 	"structs"
 	"unsafe"
 }
-var xNewDBusProxySync func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, string, string, string, uintptr, **glib.Error) uintptr
+var xNewDBusProxySync func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, uintptr, string, string, uintptr, **glib.Error) uintptr
 // Creates a proxy for accessing @interface_name on the remote object
 // at @object_path owned by @name at @connection and synchronously
 // and g_dbus_proxy_new_finish() for the asynchronous version.
 //
 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-func NewDBusProxySync(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable) (*DBusProxy, error) {
+func NewDBusProxySync(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar *string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable) (*DBusProxy, error) {
 	var cls *DBusProxy
 	var cerr *glib.Error
-	cret := xNewDBusProxySync(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
+	cret := xNewDBusProxySync(ConnectionVar.GoPointer(), FlagsVar, InfoVar, core.NullableStringToPtr(NameVar), ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
 func (x *DBusProxy) Call(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xDBusProxyCall(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 // This method is only available on UNIX.
 func (x *DBusProxy) CallWithUnixFdList(MethodNameVar string, ParametersVar *glib.Variant, FlagsVar DBusCallFlags, TimeoutMsecVar int, FdListVar *UnixFDList, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xDBusProxyCallWithUnixFdList(x.GoPointer(), MethodNameVar, ParametersVar, FlagsVar, TimeoutMsecVar, FdListVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 func (x *DBusProxy) SetPropertyGInterfaceName(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("g-interface-name", &v)
 }
 func (x *DBusProxy) SetPropertyGName(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("g-name", &v)
 }
 func (x *DBusProxy) SetPropertyGObjectPath(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("g-object-path", &v)
 }
 	return gobject.SignalConnect(x.GoPointer(), "g-signal", cbRefPtr)
 }
+// ConnectGSignalWithDetail connects to the "g-signal" signal with a detail string.
+// The detail is appended as "g-signal::<detail>".
+func (x *DBusProxy) ConnectGSignalWithDetail(detail string, cb *func(DBusProxy, string, string, uintptr)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	signalName := fmt.Sprintf("g-signal::%s", detail)
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	}
+	fcb := func(clsPtr uintptr, SenderNameVarp string, SignalNameVarp string, ParametersVarp uintptr) {
+		fa := DBusProxy{}
+		fa.Ptr = clsPtr
+		cbFn := *cb
+		cbFn(fa, SenderNameVarp, SignalNameVarp, ParametersVarp)
+	}
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+}
 // Starts asynchronous initialization of the object implementing the
 // interface. This must be done before any real use of the object after
 // initial construction. If the object also implements #GInitable you can
 }
-var xDBusProxyNew func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, string, string, string, uintptr, uintptr, uintptr)
+var xDBusProxyNew func(uintptr, DBusProxyFlags, *DBusInterfaceInfo, uintptr, string, string, uintptr, uintptr, uintptr)
 // Creates a proxy for accessing @interface_name on the remote object
 // at @object_path owned by @name at @connection and asynchronously
 // See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
 //
 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func DBusProxyNew(ConnectionVar *DBusConnection, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar *string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
-	xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	xDBusProxyNew(ConnectionVar.GoPointer(), FlagsVar, InfoVar, core.NullableStringToPtr(NameVar), ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 // #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
 func DBusProxyNewForBus(BusTypeVar BusType, FlagsVar DBusProxyFlags, InfoVar *DBusInterfaceInfo, NameVar string, ObjectPathVar string, InterfaceNameVar string, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xDBusProxyNewForBus(BusTypeVar, FlagsVar, InfoVar, NameVar, ObjectPathVar, InterfaceNameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }

M v4/gio/gdbusserver.go +2 -2


@@ -169,7 +169,7 @@ func (x *DBusServer) GetPropertyActive() bool {
169		func (x *DBusServer) SetPropertyAddress(value string) {	169		func (x *DBusServer) SetPropertyAddress(value string) {
170		var v gobject.Value	170		var v gobject.Value
171		v.Init(gobject.TypeStringVal)	171		v.Init(gobject.TypeStringVal)
172	-	v.SetString(value)	172	+	v.SetString(&value)
173		x.SetProperty("address", &v)	173		x.SetProperty("address", &v)
174		}	174		}
175			175

@@ -196,7 +196,7 @@ func (x *DBusServer) GetPropertyClientAddress() string {
196		func (x *DBusServer) SetPropertyGuid(value string) {	196		func (x *DBusServer) SetPropertyGuid(value string) {
197		var v gobject.Value	197		var v gobject.Value
198		v.Init(gobject.TypeStringVal)	198		v.Init(gobject.TypeStringVal)
199	-	v.SetString(value)	199	+	v.SetString(&value)
200		x.SetProperty("guid", &v)	200		x.SetProperty("guid", &v)
201		}	201		}
202			202

M v4/gio/gfile.go +67 -37

 	Read(CancellableVar *Cancellable) (*FileInputStream, error)
 	ReadAsync(IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
 	ReadFinish(ResVar AsyncResult) (*FileInputStream, error)
-	Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileOutputStream, error)
+	Replace(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileOutputStream, error)
-	ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
+	ReplaceAsync(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
-	ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar *string, CancellableVar *Cancellable) (bool, error)
+	ReplaceContents(ContentsVar string, LengthVar uint, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar *string, CancellableVar *Cancellable) (bool, error)
-	ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
+	ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
-	ReplaceContentsBytesAsync(ContentsVar *glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
+	ReplaceContentsBytesAsync(ContentsVar *glib.Bytes, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
 	ReplaceContentsFinish(ResVar AsyncResult, NewEtagVar *string) (bool, error)
 	ReplaceFinish(ResVar AsyncResult) (*FileOutputStream, error)
-	ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileIOStream, error)
+	ReplaceReadwrite(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileIOStream, error)
-	ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
+	ReplaceReadwriteAsync(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
 	ReplaceReadwriteFinish(ResVar AsyncResult) (*FileIOStream, error)
 	ResolveRelativePath(RelativePathVar string) *FileBase
 	SetAttribute(AttributeVar string, TypeVar FileAttributeType, ValuePVar uintptr, FlagsVar FileQueryInfoFlags, CancellableVar *Cancellable) (bool, error)
 // %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long
 // %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are
 // possible too, and depend on what kind of filesystem the file is on.
-func (x *FileBase) Replace(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileOutputStream, error) {
+func (x *FileBase) Replace(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileOutputStream, error) {
 	var cls *FileOutputStream
 	var cerr *glib.Error
-	cret := XGFileReplace(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
+	cret := XGFileReplace(x.GoPointer(), core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // When the operation is finished, @callback will be called.
 // You can then call g_file_replace_finish() to get the result
 // of the operation.
-func (x *FileBase) ReplaceAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func (x *FileBase) ReplaceAsync(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGFileReplaceAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	XGFileReplaceAsync(x.GoPointer(), core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
 }
 //
 // The returned @new_etag can be used to verify that the file hasn't
 // changed the next time it is saved over.
-func (x *FileBase) ReplaceContents(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar *string, CancellableVar *Cancellable) (bool, error) {
+func (x *FileBase) ReplaceContents(ContentsVar string, LengthVar uint, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, NewEtagVar *string, CancellableVar *Cancellable) (bool, error) {
 	var cerr *glib.Error
-	cret := XGFileReplaceContents(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, NewEtagVar, CancellableVar.GoPointer(), &cerr)
+	cret := XGFileReplaceContents(x.GoPointer(), ContentsVar, LengthVar, core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, NewEtagVar, CancellableVar.GoPointer(), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 // until @callback is called. See g_file_replace_contents_bytes_async()
 // for a #GBytes version that will automatically hold a reference to the
 // contents (without copying) for the duration of the call.
-func (x *FileBase) ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func (x *FileBase) ReplaceContentsAsync(ContentsVar string, LengthVar uint, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGFileReplaceContentsAsync(x.GoPointer(), ContentsVar, LengthVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	XGFileReplaceContentsAsync(x.GoPointer(), ContentsVar, LengthVar, core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
 }
 // When this operation has completed, @callback will be called with
 // @user_user data, and the operation can be finalized with
 // g_file_replace_contents_finish().
-func (x *FileBase) ReplaceContentsBytesAsync(ContentsVar *glib.Bytes, EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func (x *FileBase) ReplaceContentsBytesAsync(ContentsVar *glib.Bytes, EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGFileReplaceContentsBytesAsync(x.GoPointer(), ContentsVar, EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	XGFileReplaceContentsBytesAsync(x.GoPointer(), ContentsVar, core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
 }
 // Note that in many non-local file cases read and write streams are not
 // supported, so make sure you really need to do read and write streaming,
 // rather than just opening for reading or writing.
-func (x *FileBase) ReplaceReadwrite(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileIOStream, error) {
+func (x *FileBase) ReplaceReadwrite(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, CancellableVar *Cancellable) (*FileIOStream, error) {
 	var cls *FileIOStream
 	var cerr *glib.Error
-	cret := XGFileReplaceReadwrite(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
+	cret := XGFileReplaceReadwrite(x.GoPointer(), core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, CancellableVar.GoPointer(), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // When the operation is finished, @callback will be called.
 // You can then call g_file_replace_readwrite_finish() to get
 // the result of the operation.
-func (x *FileBase) ReplaceReadwriteAsync(EtagVar string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func (x *FileBase) ReplaceReadwriteAsync(EtagVar *string, MakeBackupVar bool, FlagsVar FileCreateFlags, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
-	XGFileReplaceReadwriteAsync(x.GoPointer(), EtagVar, MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	XGFileReplaceReadwriteAsync(x.GoPointer(), core.NullableStringToPtr(EtagVar), MakeBackupVar, FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
 }
 var XGFileRead func(uintptr, uintptr, **glib.Error) uintptr
 var XGFileReadAsync func(uintptr, int, uintptr, uintptr, uintptr)
 var XGFileReadFinish func(uintptr, uintptr, **glib.Error) uintptr
-var XGFileReplace func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
+var XGFileReplace func(uintptr, uintptr, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
-var XGFileReplaceAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)
+var XGFileReplaceAsync func(uintptr, uintptr, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)
-var XGFileReplaceContents func(uintptr, string, uint, string, bool, FileCreateFlags, *string, uintptr, **glib.Error) bool
+var XGFileReplaceContents func(uintptr, string, uint, uintptr, bool, FileCreateFlags, *string, uintptr, **glib.Error) bool
-var XGFileReplaceContentsAsync func(uintptr, string, uint, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)
+var XGFileReplaceContentsAsync func(uintptr, string, uint, uintptr, bool, FileCreateFlags, uintptr, uintptr, uintptr)
-var XGFileReplaceContentsBytesAsync func(uintptr, *glib.Bytes, string, bool, FileCreateFlags, uintptr, uintptr, uintptr)
+var XGFileReplaceContentsBytesAsync func(uintptr, *glib.Bytes, uintptr, bool, FileCreateFlags, uintptr, uintptr, uintptr)
 var XGFileReplaceContentsFinish func(uintptr, uintptr, *string, **glib.Error) bool
 var XGFileReplaceFinish func(uintptr, uintptr, **glib.Error) uintptr
-var XGFileReplaceReadwrite func(uintptr, string, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
+var XGFileReplaceReadwrite func(uintptr, uintptr, bool, FileCreateFlags, uintptr, **glib.Error) uintptr
-var XGFileReplaceReadwriteAsync func(uintptr, string, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)
+var XGFileReplaceReadwriteAsync func(uintptr, uintptr, bool, FileCreateFlags, int, uintptr, uintptr, uintptr)
 var XGFileReplaceReadwriteFinish func(uintptr, uintptr, **glib.Error) uintptr
 var XGFileResolveRelativePath func(uintptr, string) uintptr
 var XGFileSetAttribute func(uintptr, string, FileAttributeType, uintptr, FileQueryInfoFlags, uintptr, **glib.Error) bool
 	return cls
 }
-var xFileNewTmp func(string, **FileIOStream, **glib.Error) uintptr
+var xFileNewTmp func(uintptr, **FileIOStream, **glib.Error) uintptr
 // Opens a file in the preferred directory for temporary files (as
 // returned by g_get_tmp_dir()) and returns a #GFile and
 //
 // Unlike the other #GFile constructors, this will return %NULL if
 // a temporary file could not be created.
-func FileNewTmp(TmplVar string, IostreamVar **FileIOStream) (*FileBase, error) {
+func FileNewTmp(TmplVar *string, IostreamVar **FileIOStream) (*FileBase, error) {
 	var cls *FileBase
 	var cerr *glib.Error
-	cret := xFileNewTmp(TmplVar, IostreamVar, &cerr)
+	cret := xFileNewTmp(core.NullableStringToPtr(TmplVar), IostreamVar, &cerr)
 	if cret == 0 {
 		return nil, cerr
 }
-var xFileNewTmpAsync func(string, int, uintptr, uintptr, uintptr)
+var xFileNewTmpAsync func(uintptr, int, uintptr, uintptr, uintptr)
 // Asynchronously opens a file in the preferred directory for temporary files
 //
 // @tmpl should be a string in the GLib file name encoding
 // containing a sequence of six 'X' characters, and containing no
 // directory components. If it is %NULL, a default template is used.
-func FileNewTmpAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func FileNewTmpAsync(TmplVar *string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
-	xFileNewTmpAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	xFileNewTmpAsync(core.NullableStringToPtr(TmplVar), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
-var xFileNewTmpDirAsync func(string, int, uintptr, uintptr, uintptr)
+var xFileNewTmpDirAsync func(uintptr, int, uintptr, uintptr, uintptr)
 // Asynchronously creates a directory in the preferred directory for
 // temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
 // @tmpl should be a string in the GLib file name encoding
 // containing a sequence of six 'X' characters, and containing no
 // directory components. If it is %NULL, a default template is used.
-func FileNewTmpDirAsync(TmplVar string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+func FileNewTmpDirAsync(TmplVar *string, IoPriorityVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
-	xFileNewTmpDirAsync(TmplVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	xFileNewTmpDirAsync(core.NullableStringToPtr(TmplVar), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }

M v4/gio/gfileenumerator.go +32 -2


@@ -436,7 +436,22 @@ var xFileEnumeratorCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
436		// g_file_enumerator_close_finish().	436		// g_file_enumerator_close_finish().
437		func (x FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	437		func (x FileEnumerator) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
438			438
439	-	xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	439	+	var CallbackVarRef uintptr
			440	+	if CallbackVar != nil {
			441	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			442	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			443	+	CallbackVarRef = cbRefPtr
			444	+	} else {
			445	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			446	+	cbFn := *CallbackVar
			447	+	cbFn(arg0, arg1, arg2)
			448	+	}
			449	+	CallbackVarRef = purego.NewCallback(fcb)
			450	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			451	+	}
			452	+	}
			453	+
			454	+	xFileEnumeratorCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
440			455
441		}	456		}
442			457

@@ -688,7 +703,22 @@ var xFileEnumeratorNextFilesAsync func(uintptr, int, int, uintptr, uintptr, uint
688		// priority is %G_PRIORITY_DEFAULT.	703		// priority is %G_PRIORITY_DEFAULT.
689		func (x FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	704		func (x FileEnumerator) NextFilesAsync(NumFilesVar int, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
690			705
691	-	xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	706	+	var CallbackVarRef uintptr
			707	+	if CallbackVar != nil {
			708	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			709	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			710	+	CallbackVarRef = cbRefPtr
			711	+	} else {
			712	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			713	+	cbFn := *CallbackVar
			714	+	cbFn(arg0, arg1, arg2)
			715	+	}
			716	+	CallbackVarRef = purego.NewCallback(fcb)
			717	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			718	+	}
			719	+	}
			720	+
			721	+	xFileEnumeratorNextFilesAsync(x.GoPointer(), NumFilesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
692			722
693		}	723		}
694			724

M v4/gio/gfileinfo.go +3 -3


@@ -1249,12 +1249,12 @@ func (x *FileInfo) HasNamespace(NameSpaceVar string) bool {
1249		return cret	1249		return cret
1250		}	1250		}
1251			1251
1252	-	var xFileInfoListAttributes func(uintptr, string) []string	1252	+	var xFileInfoListAttributes func(uintptr, uintptr) []string
1253			1253
1254		// Lists the file info structure's attributes.	1254		// Lists the file info structure's attributes.
1255	-	func (x *FileInfo) ListAttributes(NameSpaceVar string) []string {	1255	+	func (x FileInfo) ListAttributes(NameSpaceVar string) []string {
1256			1256
1257	-	cret := xFileInfoListAttributes(x.GoPointer(), NameSpaceVar)	1257	+	cret := xFileInfoListAttributes(x.GoPointer(), core.NullableStringToPtr(NameSpaceVar))
1258		return cret	1258		return cret
1259		}	1259		}
1260			1260

M v4/gio/gfileinputstream.go +16 -1


@@ -389,7 +389,22 @@ var xFileInputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
389		// was cancelled, the error %G_IO_ERROR_CANCELLED will be set	389		// was cancelled, the error %G_IO_ERROR_CANCELLED will be set
390		func (x FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	390		func (x FileInputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
391			391
392	-	xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	392	+	var CallbackVarRef uintptr
			393	+	if CallbackVar != nil {
			394	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			395	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			396	+	CallbackVarRef = cbRefPtr
			397	+	} else {
			398	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			399	+	cbFn := *CallbackVar
			400	+	cbFn(arg0, arg1, arg2)
			401	+	}
			402	+	CallbackVarRef = purego.NewCallback(fcb)
			403	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			404	+	}
			405	+	}
			406	+
			407	+	xFileInputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
393			408
394		}	409		}
395			410

M v4/gio/gfileiostream.go +16 -1


@@ -492,7 +492,22 @@ var xFileIOStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr, uin
492		// g_file_io_stream_query_info().	492		// g_file_io_stream_query_info().
493		func (x FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	493		func (x FileIOStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
494			494
495	-	xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	495	+	var CallbackVarRef uintptr
			496	+	if CallbackVar != nil {
			497	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			498	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			499	+	CallbackVarRef = cbRefPtr
			500	+	} else {
			501	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			502	+	cbFn := *CallbackVar
			503	+	cbFn(arg0, arg1, arg2)
			504	+	}
			505	+	CallbackVarRef = purego.NewCallback(fcb)
			506	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			507	+	}
			508	+	}
			509	+
			510	+	xFileIOStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
496			511
497		}	512		}
498			513

M v4/gio/gfileoutputstream.go +16 -1


@@ -487,7 +487,22 @@ var xFileOutputStreamQueryInfoAsync func(uintptr, string, int, uintptr, uintptr,
487		// g_file_output_stream_query_info().	487		// g_file_output_stream_query_info().
488		func (x FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	488		func (x FileOutputStream) QueryInfoAsync(AttributesVar string, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
489			489
490	-	xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	490	+	var CallbackVarRef uintptr
			491	+	if CallbackVar != nil {
			492	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			493	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			494	+	CallbackVarRef = cbRefPtr
			495	+	} else {
			496	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			497	+	cbFn := *CallbackVar
			498	+	cbFn(arg0, arg1, arg2)
			499	+	}
			500	+	CallbackVarRef = purego.NewCallback(fcb)
			501	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			502	+	}
			503	+	}
			504	+
			505	+	xFileOutputStreamQueryInfoAsync(x.GoPointer(), AttributesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
491			506
492		}	507		}
493			508

M v4/gio/ginputstream.go +80 -5


@@ -468,7 +468,22 @@ var xInputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
468		// override one you must override all.	468		// override one you must override all.
469		func (x InputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	469		func (x InputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
470			470
471	-	xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	471	+	var CallbackVarRef uintptr
			472	+	if CallbackVar != nil {
			473	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			474	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			475	+	CallbackVarRef = cbRefPtr
			476	+	} else {
			477	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			478	+	cbFn := *CallbackVar
			479	+	cbFn(arg0, arg1, arg2)
			480	+	}
			481	+	CallbackVarRef = purego.NewCallback(fcb)
			482	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			483	+	}
			484	+	}
			485	+
			486	+	xInputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
472			487
473		}	488		}
474			489

@@ -584,7 +599,22 @@ var xInputStreamReadAllAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr,
584		// priority. Default priority is %G_PRIORITY_DEFAULT.	599		// priority. Default priority is %G_PRIORITY_DEFAULT.
585		func (x InputStream) ReadAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	600		func (x InputStream) ReadAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
586			601
587	-	xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	602	+	var CallbackVarRef uintptr
			603	+	if CallbackVar != nil {
			604	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			605	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			606	+	CallbackVarRef = cbRefPtr
			607	+	} else {
			608	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			609	+	cbFn := *CallbackVar
			610	+	cbFn(arg0, arg1, arg2)
			611	+	}
			612	+	CallbackVarRef = purego.NewCallback(fcb)
			613	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			614	+	}
			615	+	}
			616	+
			617	+	xInputStreamReadAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
588			618
589		}	619		}
590			620

@@ -637,7 +667,22 @@ var xInputStreamReadAsync func(uintptr, *[]byte, uint, int, uintptr, uintptr, ui
637		// override one you must override all.	667		// override one you must override all.
638		func (x InputStream) ReadAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	668		func (x InputStream) ReadAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
639			669
640	-	xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	670	+	var CallbackVarRef uintptr
			671	+	if CallbackVar != nil {
			672	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			673	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			674	+	CallbackVarRef = cbRefPtr
			675	+	} else {
			676	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			677	+	cbFn := *CallbackVar
			678	+	cbFn(arg0, arg1, arg2)
			679	+	}
			680	+	CallbackVarRef = purego.NewCallback(fcb)
			681	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			682	+	}
			683	+	}
			684	+
			685	+	xInputStreamReadAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
641			686
642		}	687		}
643			688

@@ -701,7 +746,22 @@ var xInputStreamReadBytesAsync func(uintptr, uint, int, uintptr, uintptr, uintpt
701		// priority. Default priority is %G_PRIORITY_DEFAULT.	746		// priority. Default priority is %G_PRIORITY_DEFAULT.
702		func (x InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	747		func (x InputStream) ReadBytesAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
703			748
704	-	xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	749	+	var CallbackVarRef uintptr
			750	+	if CallbackVar != nil {
			751	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			752	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			753	+	CallbackVarRef = cbRefPtr
			754	+	} else {
			755	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			756	+	cbFn := *CallbackVar
			757	+	cbFn(arg0, arg1, arg2)
			758	+	}
			759	+	CallbackVarRef = purego.NewCallback(fcb)
			760	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			761	+	}
			762	+	}
			763	+
			764	+	xInputStreamReadBytesAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
705			765
706		}	766		}
707			767

@@ -803,7 +863,22 @@ var xInputStreamSkipAsync func(uintptr, uint, int, uintptr, uintptr, uintptr)
803		// However, if you override one, you must override all.	863		// However, if you override one, you must override all.
804		func (x InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	864		func (x InputStream) SkipAsync(CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
805			865
806	-	xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	866	+	var CallbackVarRef uintptr
			867	+	if CallbackVar != nil {
			868	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			869	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			870	+	CallbackVarRef = cbRefPtr
			871	+	} else {
			872	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			873	+	cbFn := *CallbackVar
			874	+	cbFn(arg0, arg1, arg2)
			875	+	}
			876	+	CallbackVarRef = purego.NewCallback(fcb)
			877	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			878	+	}
			879	+	}
			880	+
			881	+	xInputStreamSkipAsync(x.GoPointer(), CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
807			882
808		}	883		}
809			884

M v4/gio/gioscheduler.go +33 -1


@@ -2,6 +2,8 @@
2		package gio	2		package gio
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -31,7 +33,37 @@ var xIoSchedulerPushJob func(uintptr, uintptr, uintptr, int, uintptr)
31		// g_io_scheduler_cancel_all_jobs().	33		// g_io_scheduler_cancel_all_jobs().
32		func IoSchedulerPushJob(JobFuncVar IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {	34		func IoSchedulerPushJob(JobFuncVar IOSchedulerJobFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify, IoPriorityVar int, CancellableVar *Cancellable) {
33			35
34	-	xIoSchedulerPushJob(glib.NewCallback(JobFuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar), IoPriorityVar, CancellableVar.GoPointer())	36	+	var JobFuncVarRef uintptr
			37	+	if JobFuncVar != nil {
			38	+	JobFuncVarPtr := uintptr(unsafe.Pointer(JobFuncVar))
			39	+	if cbRefPtr, ok := glib.GetCallback(JobFuncVarPtr); ok {
			40	+	JobFuncVarRef = cbRefPtr
			41	+	} else {
			42	+	fcb := func(arg0 *IOSchedulerJob, arg1 uintptr, arg2 uintptr) bool {
			43	+	cbFn := *JobFuncVar
			44	+	return cbFn(arg0, arg1, arg2)
			45	+	}
			46	+	JobFuncVarRef = purego.NewCallback(fcb)
			47	+	glib.SaveCallback(JobFuncVarPtr, JobFuncVarRef)
			48	+	}
			49	+	}
			50	+
			51	+	var NotifyVarRef uintptr
			52	+	if NotifyVar != nil {
			53	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			54	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			55	+	NotifyVarRef = cbRefPtr
			56	+	} else {
			57	+	fcb := func(arg0 uintptr) {
			58	+	cbFn := *NotifyVar
			59	+	cbFn(arg0)
			60	+	}
			61	+	NotifyVarRef = purego.NewCallback(fcb)
			62	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			63	+	}
			64	+	}
			65	+
			66	+	xIoSchedulerPushJob(JobFuncVarRef, UserDataVar, NotifyVarRef, IoPriorityVar, CancellableVar.GoPointer())
35			67
36		}	68		}
37			69

M v4/gio/giostream.go +32 -2


@@ -558,7 +558,22 @@ var xIOStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
558		// classes. However, if you override one you must override all.	558		// classes. However, if you override one you must override all.
559		func (x IOStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	559		func (x IOStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
560			560
561	-	xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	561	+	var CallbackVarRef uintptr
			562	+	if CallbackVar != nil {
			563	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			564	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			565	+	CallbackVarRef = cbRefPtr
			566	+	} else {
			567	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			568	+	cbFn := *CallbackVar
			569	+	cbFn(arg0, arg1, arg2)
			570	+	}
			571	+	CallbackVarRef = purego.NewCallback(fcb)
			572	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			573	+	}
			574	+	}
			575	+
			576	+	xIOStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
562			577
563		}	578		}
564			579

@@ -657,7 +672,22 @@ var xIOStreamSpliceAsync func(uintptr, uintptr, IOStreamSpliceFlags, int, uintpt
657		// result of the operation.	672		// result of the operation.
658		func (x IOStream) SpliceAsync(Stream2Var IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	673		func (x IOStream) SpliceAsync(Stream2Var IOStream, FlagsVar IOStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
659			674
660	-	xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	675	+	var CallbackVarRef uintptr
			676	+	if CallbackVar != nil {
			677	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			678	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			679	+	CallbackVarRef = cbRefPtr
			680	+	} else {
			681	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			682	+	cbFn := *CallbackVar
			683	+	cbFn(arg0, arg1, arg2)
			684	+	}
			685	+	CallbackVarRef = purego.NewCallback(fcb)
			686	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			687	+	}
			688	+	}
			689	+
			690	+	xIOStreamSpliceAsync(x.GoPointer(), Stream2Var.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
661			691
662		}	692		}
663			693

M v4/gio/giotypes.go +62 -2


@@ -400,7 +400,37 @@ var xIOSchedulerJobSendToMainloop func(uintptr, uintptr, uintptr, uintptr) bool
400		// blocking the I/O job).	400		// blocking the I/O job).
401		func (x IOSchedulerJob) SendToMainloop(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {	401		func (x IOSchedulerJob) SendToMainloop(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) bool {
402			402
403	-	cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))	403	+	var FuncVarRef uintptr
			404	+	if FuncVar != nil {
			405	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			406	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			407	+	FuncVarRef = cbRefPtr
			408	+	} else {
			409	+	fcb := func(arg0 uintptr) bool {
			410	+	cbFn := *FuncVar
			411	+	return cbFn(arg0)
			412	+	}
			413	+	FuncVarRef = purego.NewCallback(fcb)
			414	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			415	+	}
			416	+	}
			417	+
			418	+	var NotifyVarRef uintptr
			419	+	if NotifyVar != nil {
			420	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			421	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			422	+	NotifyVarRef = cbRefPtr
			423	+	} else {
			424	+	fcb := func(arg0 uintptr) {
			425	+	cbFn := *NotifyVar
			426	+	cbFn(arg0)
			427	+	}
			428	+	NotifyVarRef = purego.NewCallback(fcb)
			429	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			430	+	}
			431	+	}
			432	+
			433	+	cret := xIOSchedulerJobSendToMainloop(x.GoPointer(), FuncVarRef, UserDataVar, NotifyVarRef)
404		return cret	434		return cret
405		}	435		}
406			436

@@ -417,7 +447,37 @@ var xIOSchedulerJobSendToMainloopAsync func(uintptr, uintptr, uintptr, uintptr)
417		// g_io_scheduler_push_job() or by using refcounting for @user_data.	447		// g_io_scheduler_push_job() or by using refcounting for @user_data.
418		func (x IOSchedulerJob) SendToMainloopAsync(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {	448		func (x IOSchedulerJob) SendToMainloopAsync(FuncVar glib.SourceFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) {
419			449
420	-	xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))	450	+	var FuncVarRef uintptr
			451	+	if FuncVar != nil {
			452	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			453	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			454	+	FuncVarRef = cbRefPtr
			455	+	} else {
			456	+	fcb := func(arg0 uintptr) bool {
			457	+	cbFn := *FuncVar
			458	+	return cbFn(arg0)
			459	+	}
			460	+	FuncVarRef = purego.NewCallback(fcb)
			461	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			462	+	}
			463	+	}
			464	+
			465	+	var NotifyVarRef uintptr
			466	+	if NotifyVar != nil {
			467	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			468	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			469	+	NotifyVarRef = cbRefPtr
			470	+	} else {
			471	+	fcb := func(arg0 uintptr) {
			472	+	cbFn := *NotifyVar
			473	+	cbFn(arg0)
			474	+	}
			475	+	NotifyVarRef = purego.NewCallback(fcb)
			476	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			477	+	}
			478	+	}
			479	+
			480	+	xIOSchedulerJobSendToMainloopAsync(x.GoPointer(), FuncVarRef, UserDataVar, NotifyVarRef)
421			481
422		}	482		}
423			483

M v4/gio/gliststore.go +64 -4


@@ -100,7 +100,22 @@ var xListStoreFindWithEqualFunc func(uintptr, uintptr, uintptr, *uint) bool
100		// Since GLib 2.76 it is possible to pass `NULL` for @item.	100		// Since GLib 2.76 it is possible to pass `NULL` for @item.
101		func (x ListStore) FindWithEqualFunc(ItemVar gobject.Object, EqualFuncVar glib.EqualFunc, PositionVar uint) bool {	101		func (x ListStore) FindWithEqualFunc(ItemVar gobject.Object, EqualFuncVar glib.EqualFunc, PositionVar uint) bool {
102			102
103	-	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), PositionVar)	103	+	var EqualFuncVarRef uintptr
			104	+	if EqualFuncVar != nil {
			105	+	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
			106	+	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
			107	+	EqualFuncVarRef = cbRefPtr
			108	+	} else {
			109	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			110	+	cbFn := *EqualFuncVar
			111	+	return cbFn(arg0, arg1)
			112	+	}
			113	+	EqualFuncVarRef = purego.NewCallback(fcb)
			114	+	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
			115	+	}
			116	+	}
			117	+
			118	+	cret := xListStoreFindWithEqualFunc(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, PositionVar)
104		return cret	119		return cret
105		}	120		}
106			121

@@ -114,7 +129,22 @@ var xListStoreFindWithEqualFuncFull func(uintptr, uintptr, uintptr, uintptr, *ui
114		// Since GLib 2.76 it is possible to pass `NULL` for @item.	129		// Since GLib 2.76 it is possible to pass `NULL` for @item.
115		func (x ListStore) FindWithEqualFuncFull(ItemVar gobject.Object, EqualFuncVar glib.EqualFuncFull, UserDataVar uintptr, PositionVar uint) bool {	130		func (x ListStore) FindWithEqualFuncFull(ItemVar gobject.Object, EqualFuncVar glib.EqualFuncFull, UserDataVar uintptr, PositionVar uint) bool {
116			131
117	-	cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(EqualFuncVar), UserDataVar, PositionVar)	132	+	var EqualFuncVarRef uintptr
			133	+	if EqualFuncVar != nil {
			134	+	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
			135	+	if cbRefPtr, ok := glib.GetCallback(EqualFuncVarPtr); ok {
			136	+	EqualFuncVarRef = cbRefPtr
			137	+	} else {
			138	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			139	+	cbFn := *EqualFuncVar
			140	+	return cbFn(arg0, arg1, arg2)
			141	+	}
			142	+	EqualFuncVarRef = purego.NewCallback(fcb)
			143	+	glib.SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
			144	+	}
			145	+	}
			146	+
			147	+	cret := xListStoreFindWithEqualFuncFull(x.GoPointer(), ItemVar.GoPointer(), EqualFuncVarRef, UserDataVar, PositionVar)
118		return cret	148		return cret
119		}	149		}
120			150

@@ -146,7 +176,22 @@ var xListStoreInsertSorted func(uintptr, uintptr, uintptr, uintptr) uint
146		// This function takes a ref on @item.	176		// This function takes a ref on @item.
147		func (x ListStore) InsertSorted(ItemVar gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {	177		func (x ListStore) InsertSorted(ItemVar gobject.Object, CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) uint {
148			178
149	-	cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)	179	+	var CompareFuncVarRef uintptr
			180	+	if CompareFuncVar != nil {
			181	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			182	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
			183	+	CompareFuncVarRef = cbRefPtr
			184	+	} else {
			185	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			186	+	cbFn := *CompareFuncVar
			187	+	return cbFn(arg0, arg1, arg2)
			188	+	}
			189	+	CompareFuncVarRef = purego.NewCallback(fcb)
			190	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			191	+	}
			192	+	}
			193	+
			194	+	cret := xListStoreInsertSorted(x.GoPointer(), ItemVar.GoPointer(), CompareFuncVarRef, UserDataVar)
150		return cret	195		return cret
151		}	196		}
152			197

@@ -177,7 +222,22 @@ var xListStoreSort func(uintptr, uintptr, uintptr)
177		// Sort the items in @store according to @compare_func.	222		// Sort the items in @store according to @compare_func.
178		func (x ListStore) Sort(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) {	223		func (x ListStore) Sort(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) {
179			224
180	-	xListStoreSort(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)	225	+	var CompareFuncVarRef uintptr
			226	+	if CompareFuncVar != nil {
			227	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			228	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
			229	+	CompareFuncVarRef = cbRefPtr
			230	+	} else {
			231	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			232	+	cbFn := *CompareFuncVar
			233	+	return cbFn(arg0, arg1, arg2)
			234	+	}
			235	+	CompareFuncVarRef = purego.NewCallback(fcb)
			236	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			237	+	}
			238	+	}
			239	+
			240	+	xListStoreSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)
181			241
182		}	242		}
183			243

M v4/gio/gmemoryinputstream.go +32 -2


@@ -213,7 +213,22 @@ var xNewMemoryInputStreamFromData func([]byte, int, uintptr) uintptr
213		func NewMemoryInputStreamFromData(DataVar []byte, LenVar int, DestroyVar glib.DestroyNotify) MemoryInputStream {	213		func NewMemoryInputStreamFromData(DataVar []byte, LenVar int, DestroyVar glib.DestroyNotify) MemoryInputStream {
214		var cls *MemoryInputStream	214		var cls *MemoryInputStream
215			215
216	-	cret := xNewMemoryInputStreamFromData(DataVar, LenVar, glib.NewCallbackNullable(DestroyVar))	216	+	var DestroyVarRef uintptr
			217	+	if DestroyVar != nil {
			218	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			219	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			220	+	DestroyVarRef = cbRefPtr
			221	+	} else {
			222	+	fcb := func(arg0 uintptr) {
			223	+	cbFn := *DestroyVar
			224	+	cbFn(arg0)
			225	+	}
			226	+	DestroyVarRef = purego.NewCallback(fcb)
			227	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			228	+	}
			229	+	}
			230	+
			231	+	cret := xNewMemoryInputStreamFromData(DataVar, LenVar, DestroyVarRef)
217			232
218		if cret == 0 {	233		if cret == 0 {
219		return nil	234		return nil

@@ -237,7 +252,22 @@ var xMemoryInputStreamAddData func(uintptr, []byte, int, uintptr)
237		// Appends @data to data that can be read from the input stream	252		// Appends @data to data that can be read from the input stream
238		func (x MemoryInputStream) AddData(DataVar []byte, LenVar int, DestroyVar glib.DestroyNotify) {	253		func (x MemoryInputStream) AddData(DataVar []byte, LenVar int, DestroyVar glib.DestroyNotify) {
239			254
240	-	xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, glib.NewCallbackNullable(DestroyVar))	255	+	var DestroyVarRef uintptr
			256	+	if DestroyVar != nil {
			257	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			258	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			259	+	DestroyVarRef = cbRefPtr
			260	+	} else {
			261	+	fcb := func(arg0 uintptr) {
			262	+	cbFn := *DestroyVar
			263	+	cbFn(arg0)
			264	+	}
			265	+	DestroyVarRef = purego.NewCallback(fcb)
			266	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			267	+	}
			268	+	}
			269	+
			270	+	xMemoryInputStreamAddData(x.GoPointer(), DataVar, LenVar, DestroyVarRef)
241			271
242		}	272		}
243			273

M v4/gio/gmemoryoutputstream.go +31 -1


@@ -228,7 +228,37 @@ var xNewMemoryOutputStream func(uintptr, uint, uintptr, uintptr) uintptr
228		func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar ReallocFunc, DestroyFunctionVar glib.DestroyNotify) *MemoryOutputStream {	228		func NewMemoryOutputStream(DataVar uintptr, SizeVar uint, ReallocFunctionVar ReallocFunc, DestroyFunctionVar glib.DestroyNotify) *MemoryOutputStream {
229		var cls *MemoryOutputStream	229		var cls *MemoryOutputStream
230			230
231	-	cret := xNewMemoryOutputStream(DataVar, SizeVar, glib.NewCallbackNullable(ReallocFunctionVar), glib.NewCallbackNullable(DestroyFunctionVar))	231	+	var ReallocFunctionVarRef uintptr
			232	+	if ReallocFunctionVar != nil {
			233	+	ReallocFunctionVarPtr := uintptr(unsafe.Pointer(ReallocFunctionVar))
			234	+	if cbRefPtr, ok := glib.GetCallback(ReallocFunctionVarPtr); ok {
			235	+	ReallocFunctionVarRef = cbRefPtr
			236	+	} else {
			237	+	fcb := func(arg0 uintptr, arg1 uint) uintptr {
			238	+	cbFn := *ReallocFunctionVar
			239	+	return cbFn(arg0, arg1)
			240	+	}
			241	+	ReallocFunctionVarRef = purego.NewCallback(fcb)
			242	+	glib.SaveCallback(ReallocFunctionVarPtr, ReallocFunctionVarRef)
			243	+	}
			244	+	}
			245	+
			246	+	var DestroyFunctionVarRef uintptr
			247	+	if DestroyFunctionVar != nil {
			248	+	DestroyFunctionVarPtr := uintptr(unsafe.Pointer(DestroyFunctionVar))
			249	+	if cbRefPtr, ok := glib.GetCallback(DestroyFunctionVarPtr); ok {
			250	+	DestroyFunctionVarRef = cbRefPtr
			251	+	} else {
			252	+	fcb := func(arg0 uintptr) {
			253	+	cbFn := *DestroyFunctionVar
			254	+	cbFn(arg0)
			255	+	}
			256	+	DestroyFunctionVarRef = purego.NewCallback(fcb)
			257	+	glib.SaveCallback(DestroyFunctionVarPtr, DestroyFunctionVarRef)
			258	+	}
			259	+	}
			260	+
			261	+	cret := xNewMemoryOutputStream(DataVar, SizeVar, ReallocFunctionVarRef, DestroyFunctionVarRef)
232			262
233		if cret == 0 {	263		if cret == 0 {
234		return nil	264		return nil

M v4/gio/gmenu.go +48 -48


@@ -51,14 +51,14 @@ func NewMenu() *Menu {
51		return cls	51		return cls
52		}	52		}
53			53
54	-	var xMenuAppend func(uintptr, string, string)	54	+	var xMenuAppend func(uintptr, uintptr, uintptr)
55			55
56		// Convenience function for appending a normal menu item to the end of	56		// Convenience function for appending a normal menu item to the end of
57		// @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more	57		// @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more
58		// flexible alternative.	58		// flexible alternative.
59	-	func (x *Menu) Append(LabelVar string, DetailedActionVar string) {	59	+	func (x Menu) Append(LabelVar string, DetailedActionVar *string) {
60			60
61	-	xMenuAppend(x.GoPointer(), LabelVar, DetailedActionVar)	61	+	xMenuAppend(x.GoPointer(), core.NullableStringToPtr(LabelVar), core.NullableStringToPtr(DetailedActionVar))
62			62
63		}	63		}
64			64

@@ -73,25 +73,25 @@ func (x Menu) AppendItem(ItemVar MenuItem) {
73			73
74		}	74		}
75			75
76	-	var xMenuAppendSection func(uintptr, string, uintptr)	76	+	var xMenuAppendSection func(uintptr, uintptr, uintptr)
77			77
78		// Convenience function for appending a section menu item to the end of	78		// Convenience function for appending a section menu item to the end of
79		// @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for a	79		// @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for a
80		// more flexible alternative.	80		// more flexible alternative.
81	-	func (x Menu) AppendSection(LabelVar string, SectionVar MenuModel) {	81	+	func (x Menu) AppendSection(LabelVar string, SectionVar *MenuModel) {
82			82
83	-	xMenuAppendSection(x.GoPointer(), LabelVar, SectionVar.GoPointer())	83	+	xMenuAppendSection(x.GoPointer(), core.NullableStringToPtr(LabelVar), SectionVar.GoPointer())
84			84
85		}	85		}
86			86
87	-	var xMenuAppendSubmenu func(uintptr, string, uintptr)	87	+	var xMenuAppendSubmenu func(uintptr, uintptr, uintptr)
88			88
89		// Convenience function for appending a submenu menu item to the end of	89		// Convenience function for appending a submenu menu item to the end of
90		// @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for a	90		// @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for a
91		// more flexible alternative.	91		// more flexible alternative.
92	-	func (x Menu) AppendSubmenu(LabelVar string, SubmenuVar MenuModel) {	92	+	func (x Menu) AppendSubmenu(LabelVar string, SubmenuVar *MenuModel) {
93			93
94	-	xMenuAppendSubmenu(x.GoPointer(), LabelVar, SubmenuVar.GoPointer())	94	+	xMenuAppendSubmenu(x.GoPointer(), core.NullableStringToPtr(LabelVar), SubmenuVar.GoPointer())
95			95
96		}	96		}
97			97

@@ -111,14 +111,14 @@ func (x *Menu) Freeze() {
111			111
112		}	112		}
113			113
114	-	var xMenuInsert func(uintptr, int, string, string)	114	+	var xMenuInsert func(uintptr, int, uintptr, uintptr)
115			115
116		// Convenience function for inserting a normal menu item into @menu.	116		// Convenience function for inserting a normal menu item into @menu.
117		// Combine g_menu_item_new() and g_menu_insert_item() for a more flexible	117		// Combine g_menu_item_new() and g_menu_insert_item() for a more flexible
118		// alternative.	118		// alternative.
119	-	func (x *Menu) Insert(PositionVar int, LabelVar string, DetailedActionVar string) {	119	+	func (x Menu) Insert(PositionVar int, LabelVar string, DetailedActionVar *string) {
120			120
121	-	xMenuInsert(x.GoPointer(), PositionVar, LabelVar, DetailedActionVar)	121	+	xMenuInsert(x.GoPointer(), PositionVar, core.NullableStringToPtr(LabelVar), core.NullableStringToPtr(DetailedActionVar))
122			122
123		}	123		}
124			124

@@ -147,36 +147,36 @@ func (x Menu) InsertItem(PositionVar int, ItemVar MenuItem) {
147			147
148		}	148		}
149			149
150	-	var xMenuInsertSection func(uintptr, int, string, uintptr)	150	+	var xMenuInsertSection func(uintptr, int, uintptr, uintptr)
151			151
152		// Convenience function for inserting a section menu item into @menu.	152		// Convenience function for inserting a section menu item into @menu.
153		// Combine g_menu_item_new_section() and g_menu_insert_item() for a more	153		// Combine g_menu_item_new_section() and g_menu_insert_item() for a more
154		// flexible alternative.	154		// flexible alternative.
155	-	func (x Menu) InsertSection(PositionVar int, LabelVar string, SectionVar MenuModel) {	155	+	func (x Menu) InsertSection(PositionVar int, LabelVar string, SectionVar *MenuModel) {
156			156
157	-	xMenuInsertSection(x.GoPointer(), PositionVar, LabelVar, SectionVar.GoPointer())	157	+	xMenuInsertSection(x.GoPointer(), PositionVar, core.NullableStringToPtr(LabelVar), SectionVar.GoPointer())
158			158
159		}	159		}
160			160
161	-	var xMenuInsertSubmenu func(uintptr, int, string, uintptr)	161	+	var xMenuInsertSubmenu func(uintptr, int, uintptr, uintptr)
162			162
163		// Convenience function for inserting a submenu menu item into @menu.	163		// Convenience function for inserting a submenu menu item into @menu.
164		// Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more	164		// Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more
165		// flexible alternative.	165		// flexible alternative.
166	-	func (x Menu) InsertSubmenu(PositionVar int, LabelVar string, SubmenuVar MenuModel) {	166	+	func (x Menu) InsertSubmenu(PositionVar int, LabelVar string, SubmenuVar *MenuModel) {
167			167
168	-	xMenuInsertSubmenu(x.GoPointer(), PositionVar, LabelVar, SubmenuVar.GoPointer())	168	+	xMenuInsertSubmenu(x.GoPointer(), PositionVar, core.NullableStringToPtr(LabelVar), SubmenuVar.GoPointer())
169			169
170		}	170		}
171			171
172	-	var xMenuPrepend func(uintptr, string, string)	172	+	var xMenuPrepend func(uintptr, uintptr, uintptr)
173			173
174		// Convenience function for prepending a normal menu item to the start	174		// Convenience function for prepending a normal menu item to the start
175		// of @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more	175		// of @menu. Combine g_menu_item_new() and g_menu_insert_item() for a more
176		// flexible alternative.	176		// flexible alternative.
177	-	func (x *Menu) Prepend(LabelVar string, DetailedActionVar string) {	177	+	func (x Menu) Prepend(LabelVar string, DetailedActionVar *string) {
178			178
179	-	xMenuPrepend(x.GoPointer(), LabelVar, DetailedActionVar)	179	+	xMenuPrepend(x.GoPointer(), core.NullableStringToPtr(LabelVar), core.NullableStringToPtr(DetailedActionVar))
180			180
181		}	181		}
182			182

@@ -191,25 +191,25 @@ func (x Menu) PrependItem(ItemVar MenuItem) {
191			191
192		}	192		}
193			193
194	-	var xMenuPrependSection func(uintptr, string, uintptr)	194	+	var xMenuPrependSection func(uintptr, uintptr, uintptr)
195			195
196		// Convenience function for prepending a section menu item to the start	196		// Convenience function for prepending a section menu item to the start
197		// of @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for	197		// of @menu. Combine g_menu_item_new_section() and g_menu_insert_item() for
198		// a more flexible alternative.	198		// a more flexible alternative.
199	-	func (x Menu) PrependSection(LabelVar string, SectionVar MenuModel) {	199	+	func (x Menu) PrependSection(LabelVar string, SectionVar *MenuModel) {
200			200
201	-	xMenuPrependSection(x.GoPointer(), LabelVar, SectionVar.GoPointer())	201	+	xMenuPrependSection(x.GoPointer(), core.NullableStringToPtr(LabelVar), SectionVar.GoPointer())
202			202
203		}	203		}
204			204
205	-	var xMenuPrependSubmenu func(uintptr, string, uintptr)	205	+	var xMenuPrependSubmenu func(uintptr, uintptr, uintptr)
206			206
207		// Convenience function for prepending a submenu menu item to the start	207		// Convenience function for prepending a submenu menu item to the start
208		// of @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for	208		// of @menu. Combine g_menu_item_new_submenu() and g_menu_insert_item() for
209		// a more flexible alternative.	209		// a more flexible alternative.
210	-	func (x Menu) PrependSubmenu(LabelVar string, SubmenuVar MenuModel) {	210	+	func (x Menu) PrependSubmenu(LabelVar string, SubmenuVar *MenuModel) {
211			211
212	-	xMenuPrependSubmenu(x.GoPointer(), LabelVar, SubmenuVar.GoPointer())	212	+	xMenuPrependSubmenu(x.GoPointer(), core.NullableStringToPtr(LabelVar), SubmenuVar.GoPointer())
213			213
214		}	214		}
215			215

@@ -269,7 +269,7 @@ func MenuItemNewFromInternalPtr(ptr uintptr) *MenuItem {
269		return cls	269		return cls
270		}	270		}
271			271
272	-	var xNewMenuItem func(string, string) uintptr	272	+	var xNewMenuItem func(uintptr, uintptr) uintptr
273			273
274		// Creates a new #GMenuItem.	274		// Creates a new #GMenuItem.
275		//	275		//

@@ -279,10 +279,10 @@ var xNewMenuItem func(string, string) uintptr
279		// If @detailed_action is non-%NULL it is used to set the "action" and	279		// If @detailed_action is non-%NULL it is used to set the "action" and
280		// possibly the "target" attribute of the new item. See	280		// possibly the "target" attribute of the new item. See
281		// g_menu_item_set_detailed_action() for more information.	281		// g_menu_item_set_detailed_action() for more information.
282	-	func NewMenuItem(LabelVar string, DetailedActionVar string) *MenuItem {	282	+	func NewMenuItem(LabelVar string, DetailedActionVar string) *MenuItem {
283		var cls *MenuItem	283		var cls *MenuItem
284			284
285	-	cret := xNewMenuItem(LabelVar, DetailedActionVar)	285	+	cret := xNewMenuItem(core.NullableStringToPtr(LabelVar), core.NullableStringToPtr(DetailedActionVar))
286			286
287		if cret == 0 {	287		if cret == 0 {
288		return nil	288		return nil

@@ -312,7 +312,7 @@ func NewMenuItemFromModel(ModelVar MenuModel, ItemIndexVar int) MenuItem {
312		return cls	312		return cls
313		}	313		}
314			314
315	-	var xNewMenuItemSection func(string, uintptr) uintptr	315	+	var xNewMenuItemSection func(uintptr, uintptr) uintptr
316			316
317		// Creates a new #GMenuItem representing a section.	317		// Creates a new #GMenuItem representing a section.
318		//	318		//

@@ -378,10 +378,10 @@ var xNewMenuItemSection func(string, uintptr) uintptr
378		//	378		//
379		// </menu>	379		// </menu>
380		// ]\|	380		// ]\|
381	-	func NewMenuItemSection(LabelVar string, SectionVar MenuModel) MenuItem {	381	+	func NewMenuItemSection(LabelVar string, SectionVar MenuModel) *MenuItem {
382		var cls *MenuItem	382		var cls *MenuItem
383			383
384	-	cret := xNewMenuItemSection(LabelVar, SectionVar.GoPointer())	384	+	cret := xNewMenuItemSection(core.NullableStringToPtr(LabelVar), SectionVar.GoPointer())
385			385
386		if cret == 0 {	386		if cret == 0 {
387		return nil	387		return nil

@@ -391,16 +391,16 @@ func NewMenuItemSection(LabelVar string, SectionVar MenuModel) MenuItem {
391		return cls	391		return cls
392		}	392		}
393			393
394	-	var xNewMenuItemSubmenu func(string, uintptr) uintptr	394	+	var xNewMenuItemSubmenu func(uintptr, uintptr) uintptr
395			395
396		// Creates a new #GMenuItem representing a submenu.	396		// Creates a new #GMenuItem representing a submenu.
397		//	397		//
398		// This is a convenience API around g_menu_item_new() and	398		// This is a convenience API around g_menu_item_new() and
399		// g_menu_item_set_submenu().	399		// g_menu_item_set_submenu().
400	-	func NewMenuItemSubmenu(LabelVar string, SubmenuVar MenuModel) MenuItem {	400	+	func NewMenuItemSubmenu(LabelVar string, SubmenuVar MenuModel) *MenuItem {
401		var cls *MenuItem	401		var cls *MenuItem
402			402
403	-	cret := xNewMenuItemSubmenu(LabelVar, SubmenuVar.GoPointer())	403	+	cret := xNewMenuItemSubmenu(core.NullableStringToPtr(LabelVar), SubmenuVar.GoPointer())
404			404
405		if cret == 0 {	405		if cret == 0 {
406		return nil	406		return nil

@@ -456,7 +456,7 @@ func (x MenuItem) GetLink(LinkVar string) MenuModel {
456		return cls	456		return cls
457		}	457		}
458			458
459	-	var xMenuItemSetActionAndTarget func(uintptr, string, string, ...interface{})	459	+	var xMenuItemSetActionAndTarget func(uintptr, uintptr, uintptr, ...interface{})
460			460
461		// Sets or unsets the "action" and "target" attributes of @menu_item.	461		// Sets or unsets the "action" and "target" attributes of @menu_item.
462		//	462		//

@@ -477,13 +477,13 @@ var xMenuItemSetActionAndTarget func(uintptr, string, string, ...interface{})
477		//	477		//
478		// See also g_menu_item_set_action_and_target_value() for a	478		// See also g_menu_item_set_action_and_target_value() for a
479		// description of the semantics of the action and target attributes.	479		// description of the semantics of the action and target attributes.
480	-	func (x *MenuItem) SetActionAndTarget(ActionVar string, FormatStringVar string, varArgs ...interface{}) {	480	+	func (x MenuItem) SetActionAndTarget(ActionVar string, FormatStringVar *string, varArgs ...interface{}) {
481			481
482	-	xMenuItemSetActionAndTarget(x.GoPointer(), ActionVar, FormatStringVar, varArgs...)	482	+	xMenuItemSetActionAndTarget(x.GoPointer(), core.NullableStringToPtr(ActionVar), core.NullableStringToPtr(FormatStringVar), varArgs...)
483			483
484		}	484		}
485			485
486	-	var xMenuItemSetActionAndTargetValue func(uintptr, string, *glib.Variant)	486	+	var xMenuItemSetActionAndTargetValue func(uintptr, uintptr, *glib.Variant)
487			487
488		// Sets or unsets the "action" and "target" attributes of @menu_item.	488		// Sets or unsets the "action" and "target" attributes of @menu_item.
489		//	489		//

@@ -521,13 +521,13 @@ var xMenuItemSetActionAndTargetValue func(uintptr, string, *glib.Variant)
521		// See g_menu_item_set_action_and_target() or	521		// See g_menu_item_set_action_and_target() or
522		// g_menu_item_set_detailed_action() for two equivalent calls that are	522		// g_menu_item_set_detailed_action() for two equivalent calls that are
523		// probably more convenient for most uses.	523		// probably more convenient for most uses.
524	-	func (x MenuItem) SetActionAndTargetValue(ActionVar string, TargetValueVar glib.Variant) {	524	+	func (x MenuItem) SetActionAndTargetValue(ActionVar string, TargetValueVar *glib.Variant) {
525			525
526	-	xMenuItemSetActionAndTargetValue(x.GoPointer(), ActionVar, TargetValueVar)	526	+	xMenuItemSetActionAndTargetValue(x.GoPointer(), core.NullableStringToPtr(ActionVar), TargetValueVar)
527			527
528		}	528		}
529			529
530	-	var xMenuItemSetAttribute func(uintptr, string, string, ...interface{})	530	+	var xMenuItemSetAttribute func(uintptr, string, uintptr, ...interface{})
531			531
532		// Sets or unsets an attribute on @menu_item.	532		// Sets or unsets an attribute on @menu_item.
533		//	533		//

@@ -546,9 +546,9 @@ var xMenuItemSetAttribute func(uintptr, string, string, ...interface{})
546		//	546		//
547		// See also g_menu_item_set_attribute_value() for an equivalent call	547		// See also g_menu_item_set_attribute_value() for an equivalent call
548		// that directly accepts a #GVariant.	548		// that directly accepts a #GVariant.
549	-	func (x *MenuItem) SetAttribute(AttributeVar string, FormatStringVar string, varArgs ...interface{}) {	549	+	func (x MenuItem) SetAttribute(AttributeVar string, FormatStringVar string, varArgs ...interface{}) {
550			550
551	-	xMenuItemSetAttribute(x.GoPointer(), AttributeVar, FormatStringVar, varArgs...)	551	+	xMenuItemSetAttribute(x.GoPointer(), AttributeVar, core.NullableStringToPtr(FormatStringVar), varArgs...)
552			552
553		}	553		}
554			554

@@ -618,15 +618,15 @@ func (x *MenuItem) SetIcon(IconVar Icon) {
618			618
619		}	619		}
620			620
621	-	var xMenuItemSetLabel func(uintptr, string)	621	+	var xMenuItemSetLabel func(uintptr, uintptr)
622			622
623		// Sets or unsets the "label" attribute of @menu_item.	623		// Sets or unsets the "label" attribute of @menu_item.
624		//	624		//
625		// If @label is non-%NULL it is used as the label for the menu item. If	625		// If @label is non-%NULL it is used as the label for the menu item. If
626		// it is %NULL then the label attribute is unset.	626		// it is %NULL then the label attribute is unset.
627	-	func (x *MenuItem) SetLabel(LabelVar string) {	627	+	func (x MenuItem) SetLabel(LabelVar string) {
628			628
629	-	xMenuItemSetLabel(x.GoPointer(), LabelVar)	629	+	xMenuItemSetLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
630			630
631		}	631		}
632			632

M v4/gio/gmountoperation.go +12 -12


@@ -570,12 +570,12 @@ func (x *MountOperation) SetChoice(ChoiceVar int) {
570			570
571		}	571		}
572			572
573	-	var xMountOperationSetDomain func(uintptr, string)	573	+	var xMountOperationSetDomain func(uintptr, uintptr)
574			574
575		// Sets the mount operation's domain.	575		// Sets the mount operation's domain.
576	-	func (x *MountOperation) SetDomain(DomainVar string) {	576	+	func (x MountOperation) SetDomain(DomainVar string) {
577			577
578	-	xMountOperationSetDomain(x.GoPointer(), DomainVar)	578	+	xMountOperationSetDomain(x.GoPointer(), core.NullableStringToPtr(DomainVar))
579			579
580		}	580		}
581			581

@@ -597,12 +597,12 @@ func (x *MountOperation) SetIsTcryptSystemVolume(SystemVolumeVar bool) {
597			597
598		}	598		}
599			599
600	-	var xMountOperationSetPassword func(uintptr, string)	600	+	var xMountOperationSetPassword func(uintptr, uintptr)
601			601
602		// Sets the mount operation's password to @password.	602		// Sets the mount operation's password to @password.
603	-	func (x *MountOperation) SetPassword(PasswordVar string) {	603	+	func (x MountOperation) SetPassword(PasswordVar string) {
604			604
605	-	xMountOperationSetPassword(x.GoPointer(), PasswordVar)	605	+	xMountOperationSetPassword(x.GoPointer(), core.NullableStringToPtr(PasswordVar))
606			606
607		}	607		}
608			608

@@ -624,12 +624,12 @@ func (x *MountOperation) SetPim(PimVar uint) {
624			624
625		}	625		}
626			626
627	-	var xMountOperationSetUsername func(uintptr, string)	627	+	var xMountOperationSetUsername func(uintptr, uintptr)
628			628
629		// Sets the user name within @op to @username.	629		// Sets the user name within @op to @username.
630	-	func (x *MountOperation) SetUsername(UsernameVar string) {	630	+	func (x MountOperation) SetUsername(UsernameVar string) {
631			631
632	-	xMountOperationSetUsername(x.GoPointer(), UsernameVar)	632	+	xMountOperationSetUsername(x.GoPointer(), core.NullableStringToPtr(UsernameVar))
633			633
634		}	634		}
635			635

@@ -685,7 +685,7 @@ func (x *MountOperation) GetPropertyChoice() int {
685		func (x *MountOperation) SetPropertyDomain(value string) {	685		func (x *MountOperation) SetPropertyDomain(value string) {
686		var v gobject.Value	686		var v gobject.Value
687		v.Init(gobject.TypeStringVal)	687		v.Init(gobject.TypeStringVal)
688	-	v.SetString(value)	688	+	v.SetString(&value)
689		x.SetProperty("domain", &v)	689		x.SetProperty("domain", &v)
690		}	690		}
691			691

@@ -747,7 +747,7 @@ func (x *MountOperation) GetPropertyIsTcryptSystemVolume() bool {
747		func (x *MountOperation) SetPropertyPassword(value string) {	747		func (x *MountOperation) SetPropertyPassword(value string) {
748		var v gobject.Value	748		var v gobject.Value
749		v.Init(gobject.TypeStringVal)	749		v.Init(gobject.TypeStringVal)
750	-	v.SetString(value)	750	+	v.SetString(&value)
751		x.SetProperty("password", &v)	751		x.SetProperty("password", &v)
752		}	752		}
753			753

@@ -785,7 +785,7 @@ func (x *MountOperation) GetPropertyPim() uint {
785		func (x *MountOperation) SetPropertyUsername(value string) {	785		func (x *MountOperation) SetPropertyUsername(value string) {
786		var v gobject.Value	786		var v gobject.Value
787		v.Init(gobject.TypeStringVal)	787		v.Init(gobject.TypeStringVal)
788	-	v.SetString(value)	788	+	v.SetString(&value)
789		x.SetProperty("username", &v)	789		x.SetProperty("username", &v)
790		}	790		}
791			791

M v4/gio/gnetworkaddress.go +2 -2


@@ -150,7 +150,7 @@ func (c *NetworkAddress) SetGoPointer(ptr uintptr) {
150		func (x *NetworkAddress) SetPropertyHostname(value string) {	150		func (x *NetworkAddress) SetPropertyHostname(value string) {
151		var v gobject.Value	151		var v gobject.Value
152		v.Init(gobject.TypeStringVal)	152		v.Init(gobject.TypeStringVal)
153	-	v.SetString(value)	153	+	v.SetString(&value)
154		x.SetProperty("hostname", &v)	154		x.SetProperty("hostname", &v)
155		}	155		}
156			156

@@ -184,7 +184,7 @@ func (x *NetworkAddress) GetPropertyPort() uint {
184		func (x *NetworkAddress) SetPropertyScheme(value string) {	184		func (x *NetworkAddress) SetPropertyScheme(value string) {
185		var v gobject.Value	185		var v gobject.Value
186		v.Init(gobject.TypeStringVal)	186		v.Init(gobject.TypeStringVal)
187	-	v.SetString(value)	187	+	v.SetString(&value)
188		x.SetProperty("scheme", &v)	188		x.SetProperty("scheme", &v)
189		}	189		}
190			190

M v4/gio/gnetworkservice.go +4 -4


@@ -136,7 +136,7 @@ func (c *NetworkService) SetGoPointer(ptr uintptr) {
136		func (x *NetworkService) SetPropertyDomain(value string) {	136		func (x *NetworkService) SetPropertyDomain(value string) {
137		var v gobject.Value	137		var v gobject.Value
138		v.Init(gobject.TypeStringVal)	138		v.Init(gobject.TypeStringVal)
139	-	v.SetString(value)	139	+	v.SetString(&value)
140		x.SetProperty("domain", &v)	140		x.SetProperty("domain", &v)
141		}	141		}
142			142

@@ -153,7 +153,7 @@ func (x *NetworkService) GetPropertyDomain() string {
153		func (x *NetworkService) SetPropertyProtocol(value string) {	153		func (x *NetworkService) SetPropertyProtocol(value string) {
154		var v gobject.Value	154		var v gobject.Value
155		v.Init(gobject.TypeStringVal)	155		v.Init(gobject.TypeStringVal)
156	-	v.SetString(value)	156	+	v.SetString(&value)
157		x.SetProperty("protocol", &v)	157		x.SetProperty("protocol", &v)
158		}	158		}
159			159

@@ -170,7 +170,7 @@ func (x *NetworkService) GetPropertyProtocol() string {
170		func (x *NetworkService) SetPropertyScheme(value string) {	170		func (x *NetworkService) SetPropertyScheme(value string) {
171		var v gobject.Value	171		var v gobject.Value
172		v.Init(gobject.TypeStringVal)	172		v.Init(gobject.TypeStringVal)
173	-	v.SetString(value)	173	+	v.SetString(&value)
174		x.SetProperty("scheme", &v)	174		x.SetProperty("scheme", &v)
175		}	175		}
176			176

@@ -187,7 +187,7 @@ func (x *NetworkService) GetPropertyScheme() string {
187		func (x *NetworkService) SetPropertyService(value string) {	187		func (x *NetworkService) SetPropertyService(value string) {
188		var v gobject.Value	188		var v gobject.Value
189		v.Init(gobject.TypeStringVal)	189		v.Init(gobject.TypeStringVal)
190	-	v.SetString(value)	190	+	v.SetString(&value)
191		x.SetProperty("service", &v)	191		x.SetProperty("service", &v)
192		}	192		}
193			193

M v4/gio/gnotification.go +12 -12


@@ -107,7 +107,7 @@ func (x *Notification) AddButton(LabelVar string, DetailedActionVar string) {
107			107
108		}	108		}
109			109
110	-	var xNotificationAddButtonWithTarget func(uintptr, string, string, string, ...interface{})	110	+	var xNotificationAddButtonWithTarget func(uintptr, string, string, uintptr, ...interface{})
111			111
112		// Adds a button to @notification that activates @action when clicked.	112		// Adds a button to @notification that activates @action when clicked.
113		// @action must be an application-wide action (it must start with "app.").	113		// @action must be an application-wide action (it must start with "app.").

@@ -116,9 +116,9 @@ var xNotificationAddButtonWithTarget func(uintptr, string, string, string, ...in
116		// positional parameters into a #GVariant instance, similar to	116		// positional parameters into a #GVariant instance, similar to
117		// g_variant_new(). @action will be activated with that #GVariant as its	117		// g_variant_new(). @action will be activated with that #GVariant as its
118		// parameter.	118		// parameter.
119	-	func (x *Notification) AddButtonWithTarget(LabelVar string, ActionVar string, TargetFormatVar string, varArgs ...interface{}) {	119	+	func (x Notification) AddButtonWithTarget(LabelVar string, ActionVar string, TargetFormatVar string, varArgs ...interface{}) {
120			120
121	-	xNotificationAddButtonWithTarget(x.GoPointer(), LabelVar, ActionVar, TargetFormatVar, varArgs...)	121	+	xNotificationAddButtonWithTarget(x.GoPointer(), LabelVar, ActionVar, core.NullableStringToPtr(TargetFormatVar), varArgs...)
122			122
123		}	123		}
124			124

@@ -135,16 +135,16 @@ func (x *Notification) AddButtonWithTargetValue(LabelVar string, ActionVar strin
135			135
136		}	136		}
137			137
138	-	var xNotificationSetBody func(uintptr, string)	138	+	var xNotificationSetBody func(uintptr, uintptr)
139			139
140		// Sets the body of @notification to @body.	140		// Sets the body of @notification to @body.
141	-	func (x *Notification) SetBody(BodyVar string) {	141	+	func (x Notification) SetBody(BodyVar string) {
142			142
143	-	xNotificationSetBody(x.GoPointer(), BodyVar)	143	+	xNotificationSetBody(x.GoPointer(), core.NullableStringToPtr(BodyVar))
144			144
145		}	145		}
146			146
147	-	var xNotificationSetCategory func(uintptr, string)	147	+	var xNotificationSetCategory func(uintptr, uintptr)
148			148
149		// Sets the type of @notification to @category. Categories have a main	149		// Sets the type of @notification to @category. Categories have a main
150		// type like `email`, `im` or `device` and can have a detail separated	150		// type like `email`, `im` or `device` and can have a detail separated

@@ -152,9 +152,9 @@ var xNotificationSetCategory func(uintptr, string)
152		// helps the notification server to select proper feedback to the user.	152		// helps the notification server to select proper feedback to the user.
153		//	153		//
154		// Standard categories are [listed in the specification](https://specifications.freedesktop.org/notification-spec/latest/ar01s06.html).	154		// Standard categories are [listed in the specification](https://specifications.freedesktop.org/notification-spec/latest/ar01s06.html).
155	-	func (x *Notification) SetCategory(CategoryVar string) {	155	+	func (x Notification) SetCategory(CategoryVar string) {
156			156
157	-	xNotificationSetCategory(x.GoPointer(), CategoryVar)	157	+	xNotificationSetCategory(x.GoPointer(), core.NullableStringToPtr(CategoryVar))
158			158
159		}	159		}
160			160

@@ -177,7 +177,7 @@ func (x *Notification) SetDefaultAction(DetailedActionVar string) {
177			177
178		}	178		}
179			179
180	-	var xNotificationSetDefaultActionAndTarget func(uintptr, string, string, ...interface{})	180	+	var xNotificationSetDefaultActionAndTarget func(uintptr, string, uintptr, ...interface{})
181			181
182		// Sets the default action of @notification to @action. This action is	182		// Sets the default action of @notification to @action. This action is
183		// activated when the notification is clicked on. It must be an	183		// activated when the notification is clicked on. It must be an

@@ -190,9 +190,9 @@ var xNotificationSetDefaultActionAndTarget func(uintptr, string, string, ...inte
190		//	190		//
191		// When no default action is set, the application that the notification	191		// When no default action is set, the application that the notification
192		// was sent on is activated.	192		// was sent on is activated.
193	-	func (x *Notification) SetDefaultActionAndTarget(ActionVar string, TargetFormatVar string, varArgs ...interface{}) {	193	+	func (x Notification) SetDefaultActionAndTarget(ActionVar string, TargetFormatVar string, varArgs ...interface{}) {
194			194
195	-	xNotificationSetDefaultActionAndTarget(x.GoPointer(), ActionVar, TargetFormatVar, varArgs...)	195	+	xNotificationSetDefaultActionAndTarget(x.GoPointer(), ActionVar, core.NullableStringToPtr(TargetFormatVar), varArgs...)
196			196
197		}	197		}
198			198

M v4/gio/goutputstream.go +128 -8


@@ -628,7 +628,22 @@ var xOutputStreamCloseAsync func(uintptr, int, uintptr, uintptr, uintptr)
628		// classes. However, if you override one you must override all.	628		// classes. However, if you override one you must override all.
629		func (x OutputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	629		func (x OutputStream) CloseAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
630			630
631	-	xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	631	+	var CallbackVarRef uintptr
			632	+	if CallbackVar != nil {
			633	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			634	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			635	+	CallbackVarRef = cbRefPtr
			636	+	} else {
			637	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			638	+	cbFn := *CallbackVar
			639	+	cbFn(arg0, arg1, arg2)
			640	+	}
			641	+	CallbackVarRef = purego.NewCallback(fcb)
			642	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			643	+	}
			644	+	}
			645	+
			646	+	xOutputStreamCloseAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
632			647
633		}	648		}
634			649

@@ -679,7 +694,22 @@ var xOutputStreamFlushAsync func(uintptr, int, uintptr, uintptr, uintptr)
679		// result of the operation.	694		// result of the operation.
680		func (x OutputStream) FlushAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	695		func (x OutputStream) FlushAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
681			696
682	-	xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	697	+	var CallbackVarRef uintptr
			698	+	if CallbackVar != nil {
			699	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			700	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			701	+	CallbackVarRef = cbRefPtr
			702	+	} else {
			703	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			704	+	cbFn := *CallbackVar
			705	+	cbFn(arg0, arg1, arg2)
			706	+	}
			707	+	CallbackVarRef = purego.NewCallback(fcb)
			708	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			709	+	}
			710	+	}
			711	+
			712	+	xOutputStreamFlushAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
683			713
684		}	714		}
685			715

@@ -788,7 +818,22 @@ var xOutputStreamSpliceAsync func(uintptr, uintptr, OutputStreamSpliceFlags, int
788		// g_output_stream_splice().	818		// g_output_stream_splice().
789		func (x OutputStream) SpliceAsync(SourceVar InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	819		func (x OutputStream) SpliceAsync(SourceVar InputStream, FlagsVar OutputStreamSpliceFlags, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
790			820
791	-	xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	821	+	var CallbackVarRef uintptr
			822	+	if CallbackVar != nil {
			823	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			824	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			825	+	CallbackVarRef = cbRefPtr
			826	+	} else {
			827	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			828	+	cbFn := *CallbackVar
			829	+	cbFn(arg0, arg1, arg2)
			830	+	}
			831	+	CallbackVarRef = purego.NewCallback(fcb)
			832	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			833	+	}
			834	+	}
			835	+
			836	+	xOutputStreamSpliceAsync(x.GoPointer(), SourceVar.GoPointer(), FlagsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
792			837
793		}	838		}
794			839

@@ -910,7 +955,22 @@ var xOutputStreamWriteAllAsync func(uintptr, []byte, uint, int, uintptr, uintptr
910		// until @callback is called.	955		// until @callback is called.
911		func (x OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	956		func (x OutputStream) WriteAllAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
912			957
913	-	xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	958	+	var CallbackVarRef uintptr
			959	+	if CallbackVar != nil {
			960	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			961	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			962	+	CallbackVarRef = cbRefPtr
			963	+	} else {
			964	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			965	+	cbFn := *CallbackVar
			966	+	cbFn(arg0, arg1, arg2)
			967	+	}
			968	+	CallbackVarRef = purego.NewCallback(fcb)
			969	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			970	+	}
			971	+	}
			972	+
			973	+	xOutputStreamWriteAllAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
914			974
915		}	975		}
916			976

@@ -976,7 +1036,22 @@ var xOutputStreamWriteAsync func(uintptr, []byte, uint, int, uintptr, uintptr, u
976		// the contents (without copying) for the duration of the call.	1036		// the contents (without copying) for the duration of the call.
977		func (x OutputStream) WriteAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	1037		func (x OutputStream) WriteAsync(BufferVar []byte, CountVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
978			1038
979	-	xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1039	+	var CallbackVarRef uintptr
			1040	+	if CallbackVar != nil {
			1041	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1042	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1043	+	CallbackVarRef = cbRefPtr
			1044	+	} else {
			1045	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1046	+	cbFn := *CallbackVar
			1047	+	cbFn(arg0, arg1, arg2)
			1048	+	}
			1049	+	CallbackVarRef = purego.NewCallback(fcb)
			1050	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1051	+	}
			1052	+	}
			1053	+
			1054	+	xOutputStreamWriteAsync(x.GoPointer(), BufferVar, CountVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
980			1055
981		}	1056		}
982			1057

@@ -1021,7 +1096,22 @@ var xOutputStreamWriteBytesAsync func(uintptr, *glib.Bytes, int, uintptr, uintpt
1021		// g_output_stream_write_bytes().	1096		// g_output_stream_write_bytes().
1022		func (x OutputStream) WriteBytesAsync(BytesVar glib.Bytes, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	1097		func (x OutputStream) WriteBytesAsync(BytesVar glib.Bytes, IoPriorityVar int, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
1023			1098
1024	-	xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1099	+	var CallbackVarRef uintptr
			1100	+	if CallbackVar != nil {
			1101	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1102	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1103	+	CallbackVarRef = cbRefPtr
			1104	+	} else {
			1105	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1106	+	cbFn := *CallbackVar
			1107	+	cbFn(arg0, arg1, arg2)
			1108	+	}
			1109	+	CallbackVarRef = purego.NewCallback(fcb)
			1110	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1111	+	}
			1112	+	}
			1113	+
			1114	+	xOutputStreamWriteBytesAsync(x.GoPointer(), BytesVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1025			1115
1026		}	1116		}
1027			1117

@@ -1144,7 +1234,22 @@ var xOutputStreamWritevAllAsync func(uintptr, []OutputVector, uint, int, uintptr
1144		// of @vectors might be changed by this function.	1234		// of @vectors might be changed by this function.
1145		func (x OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	1235		func (x OutputStream) WritevAllAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1146			1236
1147	-	xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1237	+	var CallbackVarRef uintptr
			1238	+	if CallbackVar != nil {
			1239	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1240	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1241	+	CallbackVarRef = cbRefPtr
			1242	+	} else {
			1243	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1244	+	cbFn := *CallbackVar
			1245	+	cbFn(arg0, arg1, arg2)
			1246	+	}
			1247	+	CallbackVarRef = purego.NewCallback(fcb)
			1248	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1249	+	}
			1250	+	}
			1251	+
			1252	+	xOutputStreamWritevAllAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1148			1253
1149		}	1254		}
1150			1255

@@ -1205,7 +1310,22 @@ var xOutputStreamWritevAsync func(uintptr, []OutputVector, uint, int, uintptr, u
1205		// until @callback is called.	1310		// until @callback is called.
1206		func (x OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	1311		func (x OutputStream) WritevAsync(VectorsVar []OutputVector, NVectorsVar uint, IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
1207			1312
1208	-	xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	1313	+	var CallbackVarRef uintptr
			1314	+	if CallbackVar != nil {
			1315	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1316	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1317	+	CallbackVarRef = cbRefPtr
			1318	+	} else {
			1319	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1320	+	cbFn := *CallbackVar
			1321	+	cbFn(arg0, arg1, arg2)
			1322	+	}
			1323	+	CallbackVarRef = purego.NewCallback(fcb)
			1324	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1325	+	}
			1326	+	}
			1327	+
			1328	+	xOutputStreamWritevAsync(x.GoPointer(), VectorsVar, NVectorsVar, IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
1209			1329
1210		}	1330		}
1211			1331

M v4/gio/gpermission.go +32 -2


@@ -249,7 +249,22 @@ var xPermissionAcquireAsync func(uintptr, uintptr, uintptr, uintptr)
249		// g_permission_acquire().	249		// g_permission_acquire().
250		func (x Permission) AcquireAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	250		func (x Permission) AcquireAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
251			251
252	-	xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	252	+	var CallbackVarRef uintptr
			253	+	if CallbackVar != nil {
			254	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			255	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			256	+	CallbackVarRef = cbRefPtr
			257	+	} else {
			258	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			259	+	cbFn := *CallbackVar
			260	+	cbFn(arg0, arg1, arg2)
			261	+	}
			262	+	CallbackVarRef = purego.NewCallback(fcb)
			263	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			264	+	}
			265	+	}
			266	+
			267	+	xPermissionAcquireAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
253			268
254		}	269		}
255			270

@@ -353,7 +368,22 @@ var xPermissionReleaseAsync func(uintptr, uintptr, uintptr, uintptr)
353		// g_permission_release().	368		// g_permission_release().
354		func (x Permission) ReleaseAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	369		func (x Permission) ReleaseAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
355			370
356	-	xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	371	+	var CallbackVarRef uintptr
			372	+	if CallbackVar != nil {
			373	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			374	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			375	+	CallbackVarRef = cbRefPtr
			376	+	} else {
			377	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			378	+	cbFn := *CallbackVar
			379	+	cbFn(arg0, arg1, arg2)
			380	+	}
			381	+	CallbackVarRef = purego.NewCallback(fcb)
			382	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			383	+	}
			384	+	}
			385	+
			386	+	xPermissionReleaseAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
357			387
358		}	388		}
359			389

M v4/gio/gpropertyaction.go +2 -2


@@ -147,7 +147,7 @@ func (x *PropertyAction) GetPropertyInvertBoolean() bool {
147		func (x *PropertyAction) SetPropertyName(value string) {	147		func (x *PropertyAction) SetPropertyName(value string) {
148		var v gobject.Value	148		var v gobject.Value
149		v.Init(gobject.TypeStringVal)	149		v.Init(gobject.TypeStringVal)
150	-	v.SetString(value)	150	+	v.SetString(&value)
151		x.SetProperty("name", &v)	151		x.SetProperty("name", &v)
152		}	152		}
153			153

@@ -177,7 +177,7 @@ func (x *PropertyAction) GetPropertyParameterType() uintptr {
177		func (x *PropertyAction) SetPropertyPropertyName(value string) {	177		func (x *PropertyAction) SetPropertyPropertyName(value string) {
178		var v gobject.Value	178		var v gobject.Value
179		v.Init(gobject.TypeStringVal)	179		v.Init(gobject.TypeStringVal)
180	-	v.SetString(value)	180	+	v.SetString(&value)
181		x.SetProperty("property-name", &v)	181		x.SetProperty("property-name", &v)
182		}	182		}
183			183

M v4/gio/gproxyaddress.go +9 -9


@@ -47,7 +47,7 @@ func ProxyAddressNewFromInternalPtr(ptr uintptr) *ProxyAddress {
47		return cls	47		return cls
48		}	48		}
49			49
50	-	var xNewProxyAddress func(uintptr, uint16, string, string, uint16, string, string) uintptr	50	+	var xNewProxyAddress func(uintptr, uint16, string, string, uint16, uintptr, uintptr) uintptr
51			51
52		// Creates a new #GProxyAddress for @inetaddr with @protocol that should	52		// Creates a new #GProxyAddress for @inetaddr with @protocol that should
53		// tunnel through @dest_hostname and @dest_port.	53		// tunnel through @dest_hostname and @dest_port.

@@ -55,10 +55,10 @@ var xNewProxyAddress func(uintptr, uint16, string, string, uint16, string, strin
55		// (Note that this method doesn't set the #GProxyAddress:uri or	55		// (Note that this method doesn't set the #GProxyAddress:uri or
56		// #GProxyAddress:destination-protocol fields; use g_object_new()	56		// #GProxyAddress:destination-protocol fields; use g_object_new()
57		// directly if you want to set those.)	57		// directly if you want to set those.)
58	-	func NewProxyAddress(InetaddrVar InetAddress, PortVar uint16, ProtocolVar string, DestHostnameVar string, DestPortVar uint16, UsernameVar string, PasswordVar string) ProxyAddress {	58	+	func NewProxyAddress(InetaddrVar InetAddress, PortVar uint16, ProtocolVar string, DestHostnameVar string, DestPortVar uint16, UsernameVar string, PasswordVar string) ProxyAddress {
59		var cls *ProxyAddress	59		var cls *ProxyAddress
60			60
61	-	cret := xNewProxyAddress(InetaddrVar.GoPointer(), PortVar, ProtocolVar, DestHostnameVar, DestPortVar, UsernameVar, PasswordVar)	61	+	cret := xNewProxyAddress(InetaddrVar.GoPointer(), PortVar, ProtocolVar, DestHostnameVar, DestPortVar, core.NullableStringToPtr(UsernameVar), core.NullableStringToPtr(PasswordVar))
62			62
63		if cret == 0 {	63		if cret == 0 {
64		return nil	64		return nil

@@ -152,7 +152,7 @@ func (c *ProxyAddress) SetGoPointer(ptr uintptr) {
152		func (x *ProxyAddress) SetPropertyDestinationHostname(value string) {	152		func (x *ProxyAddress) SetPropertyDestinationHostname(value string) {
153		var v gobject.Value	153		var v gobject.Value
154		v.Init(gobject.TypeStringVal)	154		v.Init(gobject.TypeStringVal)
155	-	v.SetString(value)	155	+	v.SetString(&value)
156		x.SetProperty("destination-hostname", &v)	156		x.SetProperty("destination-hostname", &v)
157		}	157		}
158			158

@@ -187,7 +187,7 @@ func (x *ProxyAddress) GetPropertyDestinationPort() uint {
187		func (x *ProxyAddress) SetPropertyDestinationProtocol(value string) {	187		func (x *ProxyAddress) SetPropertyDestinationProtocol(value string) {
188		var v gobject.Value	188		var v gobject.Value
189		v.Init(gobject.TypeStringVal)	189		v.Init(gobject.TypeStringVal)
190	-	v.SetString(value)	190	+	v.SetString(&value)
191		x.SetProperty("destination-protocol", &v)	191		x.SetProperty("destination-protocol", &v)
192		}	192		}
193			193

@@ -205,7 +205,7 @@ func (x *ProxyAddress) GetPropertyDestinationProtocol() string {
205		func (x *ProxyAddress) SetPropertyPassword(value string) {	205		func (x *ProxyAddress) SetPropertyPassword(value string) {
206		var v gobject.Value	206		var v gobject.Value
207		v.Init(gobject.TypeStringVal)	207		v.Init(gobject.TypeStringVal)
208	-	v.SetString(value)	208	+	v.SetString(&value)
209		x.SetProperty("password", &v)	209		x.SetProperty("password", &v)
210		}	210		}
211			211

@@ -222,7 +222,7 @@ func (x *ProxyAddress) GetPropertyPassword() string {
222		func (x *ProxyAddress) SetPropertyProtocol(value string) {	222		func (x *ProxyAddress) SetPropertyProtocol(value string) {
223		var v gobject.Value	223		var v gobject.Value
224		v.Init(gobject.TypeStringVal)	224		v.Init(gobject.TypeStringVal)
225	-	v.SetString(value)	225	+	v.SetString(&value)
226		x.SetProperty("protocol", &v)	226		x.SetProperty("protocol", &v)
227		}	227		}
228			228

@@ -240,7 +240,7 @@ func (x *ProxyAddress) GetPropertyProtocol() string {
240		func (x *ProxyAddress) SetPropertyUri(value string) {	240		func (x *ProxyAddress) SetPropertyUri(value string) {
241		var v gobject.Value	241		var v gobject.Value
242		v.Init(gobject.TypeStringVal)	242		v.Init(gobject.TypeStringVal)
243	-	v.SetString(value)	243	+	v.SetString(&value)
244		x.SetProperty("uri", &v)	244		x.SetProperty("uri", &v)
245		}	245		}
246			246

@@ -258,7 +258,7 @@ func (x *ProxyAddress) GetPropertyUri() string {
258		func (x *ProxyAddress) SetPropertyUsername(value string) {	258		func (x *ProxyAddress) SetPropertyUsername(value string) {
259		var v gobject.Value	259		var v gobject.Value
260		v.Init(gobject.TypeStringVal)	260		v.Init(gobject.TypeStringVal)
261	-	v.SetString(value)	261	+	v.SetString(&value)
262		x.SetProperty("username", &v)	262		x.SetProperty("username", &v)
263		}	263		}
264			264

M v4/gio/gproxyaddressenumerator.go +1 -1


@@ -265,7 +265,7 @@ func (x *ProxyAddressEnumerator) GetPropertyDefaultPort() uint {
265		func (x *ProxyAddressEnumerator) SetPropertyUri(value string) {	265		func (x *ProxyAddressEnumerator) SetPropertyUri(value string) {
266		var v gobject.Value	266		var v gobject.Value
267		v.Init(gobject.TypeStringVal)	267		v.Init(gobject.TypeStringVal)
268	-	v.SetString(value)	268	+	v.SetString(&value)
269		x.SetProperty("uri", &v)	269		x.SetProperty("uri", &v)
270		}	270		}
271			271

M v4/gio/gresolver.go +80 -5


@@ -531,7 +531,22 @@ var xResolverLookupByAddressAsync func(uintptr, uintptr, uintptr, uintptr, uintp
531		// call g_resolver_lookup_by_address_finish() to get the final result.	531		// call g_resolver_lookup_by_address_finish() to get the final result.
532		func (x Resolver) LookupByAddressAsync(AddressVar InetAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	532		func (x Resolver) LookupByAddressAsync(AddressVar InetAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
533			533
534	-	xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	534	+	var CallbackVarRef uintptr
			535	+	if CallbackVar != nil {
			536	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			537	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			538	+	CallbackVarRef = cbRefPtr
			539	+	} else {
			540	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			541	+	cbFn := *CallbackVar
			542	+	cbFn(arg0, arg1, arg2)
			543	+	}
			544	+	CallbackVarRef = purego.NewCallback(fcb)
			545	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			546	+	}
			547	+	}
			548	+
			549	+	xResolverLookupByAddressAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
535			550
536		}	551		}
537			552

@@ -598,7 +613,22 @@ var xResolverLookupByNameAsync func(uintptr, string, uintptr, uintptr, uintptr)
598		// See g_resolver_lookup_by_name() for more details.	613		// See g_resolver_lookup_by_name() for more details.
599		func (x Resolver) LookupByNameAsync(HostnameVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	614		func (x Resolver) LookupByNameAsync(HostnameVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
600			615
601	-	xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	616	+	var CallbackVarRef uintptr
			617	+	if CallbackVar != nil {
			618	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			619	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			620	+	CallbackVarRef = cbRefPtr
			621	+	} else {
			622	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			623	+	cbFn := *CallbackVar
			624	+	cbFn(arg0, arg1, arg2)
			625	+	}
			626	+	CallbackVarRef = purego.NewCallback(fcb)
			627	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			628	+	}
			629	+	}
			630	+
			631	+	xResolverLookupByNameAsync(x.GoPointer(), HostnameVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
602			632
603		}	633		}
604			634

@@ -645,7 +675,22 @@ var xResolverLookupByNameWithFlagsAsync func(uintptr, string, ResolverNameLookup
645		// See g_resolver_lookup_by_name() for more details.	675		// See g_resolver_lookup_by_name() for more details.
646		func (x Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	676		func (x Resolver) LookupByNameWithFlagsAsync(HostnameVar string, FlagsVar ResolverNameLookupFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
647			677
648	-	xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	678	+	var CallbackVarRef uintptr
			679	+	if CallbackVar != nil {
			680	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			681	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			682	+	CallbackVarRef = cbRefPtr
			683	+	} else {
			684	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			685	+	cbFn := *CallbackVar
			686	+	cbFn(arg0, arg1, arg2)
			687	+	}
			688	+	CallbackVarRef = purego.NewCallback(fcb)
			689	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			690	+	}
			691	+	}
			692	+
			693	+	xResolverLookupByNameWithFlagsAsync(x.GoPointer(), HostnameVar, FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
649			694
650		}	695		}
651			696

@@ -699,7 +744,22 @@ var xResolverLookupRecordsAsync func(uintptr, string, ResolverRecordType, uintpt
699		// g_resolver_lookup_records() for more details.	744		// g_resolver_lookup_records() for more details.
700		func (x Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	745		func (x Resolver) LookupRecordsAsync(RrnameVar string, RecordTypeVar ResolverRecordType, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
701			746
702	-	xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	747	+	var CallbackVarRef uintptr
			748	+	if CallbackVar != nil {
			749	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			750	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			751	+	CallbackVarRef = cbRefPtr
			752	+	} else {
			753	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			754	+	cbFn := *CallbackVar
			755	+	cbFn(arg0, arg1, arg2)
			756	+	}
			757	+	CallbackVarRef = purego.NewCallback(fcb)
			758	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			759	+	}
			760	+	}
			761	+
			762	+	xResolverLookupRecordsAsync(x.GoPointer(), RrnameVar, RecordTypeVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
703			763
704		}	764		}
705			765

@@ -767,7 +827,22 @@ var xResolverLookupServiceAsync func(uintptr, string, string, string, uintptr, u
767		// details.	827		// details.
768		func (x Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	828		func (x Resolver) LookupServiceAsync(ServiceVar string, ProtocolVar string, DomainVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
769			829
770	-	xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	830	+	var CallbackVarRef uintptr
			831	+	if CallbackVar != nil {
			832	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			833	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			834	+	CallbackVarRef = cbRefPtr
			835	+	} else {
			836	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			837	+	cbFn := *CallbackVar
			838	+	cbFn(arg0, arg1, arg2)
			839	+	}
			840	+	CallbackVarRef = purego.NewCallback(fcb)
			841	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			842	+	}
			843	+	}
			844	+
			845	+	xResolverLookupServiceAsync(x.GoPointer(), ServiceVar, ProtocolVar, DomainVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
771			846
772		}	847		}
773			848

M v4/gio/gsettings.go +113 -8


@@ -2,6 +2,7 @@
2		package gio	2		package gio
3			3
4		import (	4		import (
			5	+	"fmt"
5		"structs"	6		"structs"
6		"unsafe"	7		"unsafe"
7			8

@@ -629,7 +630,7 @@ func NewSettings(SchemaIdVar string) *Settings {
629		return cls	630		return cls
630		}	631		}
631			632
632	-	var xNewSettingsFull func(*SettingsSchema, uintptr, string) uintptr	633	+	var xNewSettingsFull func(*SettingsSchema, uintptr, uintptr) uintptr
633			634
634		// Creates a new [class@Gio.Settings] object with a given schema, backend and	635		// Creates a new [class@Gio.Settings] object with a given schema, backend and
635		// path.	636		// path.

@@ -654,10 +655,10 @@ var xNewSettingsFull func(*SettingsSchema, uintptr, string) uintptr
654		// error if @path is `NULL` and the schema has no path of its own or if	655		// error if @path is `NULL` and the schema has no path of its own or if
655		// @path is non-`NULL` and not equal to the path that the schema does	656		// @path is non-`NULL` and not equal to the path that the schema does
656		// have.	657		// have.
657	-	func NewSettingsFull(SchemaVar SettingsSchema, BackendVar SettingsBackend, PathVar string) *Settings {	658	+	func NewSettingsFull(SchemaVar SettingsSchema, BackendVar SettingsBackend, PathVar string) Settings {
658		var cls *Settings	659		var cls *Settings
659			660
660	-	cret := xNewSettingsFull(SchemaVar, BackendVar.GoPointer(), PathVar)	661	+	cret := xNewSettingsFull(SchemaVar, BackendVar.GoPointer(), core.NullableStringToPtr(PathVar))
661			662
662		if cret == 0 {	663		if cret == 0 {
663		return nil	664		return nil

@@ -793,7 +794,52 @@ var xSettingsBindWithMapping func(uintptr, string, uintptr, string, SettingsBind
793		// binding overrides the first one.	794		// binding overrides the first one.
794		func (x Settings) BindWithMapping(KeyVar string, ObjectVar gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar SettingsBindGetMapping, SetMappingVar SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	795		func (x Settings) BindWithMapping(KeyVar string, ObjectVar gobject.Object, PropertyVar string, FlagsVar SettingsBindFlags, GetMappingVar SettingsBindGetMapping, SetMappingVar SettingsBindSetMapping, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
795			796
796	-	xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, glib.NewCallbackNullable(GetMappingVar), glib.NewCallbackNullable(SetMappingVar), UserDataVar, glib.NewCallback(DestroyVar))	797	+	var GetMappingVarRef uintptr
			798	+	if GetMappingVar != nil {
			799	+	GetMappingVarPtr := uintptr(unsafe.Pointer(GetMappingVar))
			800	+	if cbRefPtr, ok := glib.GetCallback(GetMappingVarPtr); ok {
			801	+	GetMappingVarRef = cbRefPtr
			802	+	} else {
			803	+	fcb := func(arg0 gobject.Value, arg1 glib.Variant, arg2 uintptr) bool {
			804	+	cbFn := *GetMappingVar
			805	+	return cbFn(arg0, arg1, arg2)
			806	+	}
			807	+	GetMappingVarRef = purego.NewCallback(fcb)
			808	+	glib.SaveCallback(GetMappingVarPtr, GetMappingVarRef)
			809	+	}
			810	+	}
			811	+
			812	+	var SetMappingVarRef uintptr
			813	+	if SetMappingVar != nil {
			814	+	SetMappingVarPtr := uintptr(unsafe.Pointer(SetMappingVar))
			815	+	if cbRefPtr, ok := glib.GetCallback(SetMappingVarPtr); ok {
			816	+	SetMappingVarRef = cbRefPtr
			817	+	} else {
			818	+	fcb := func(arg0 gobject.Value, arg1 glib.VariantType, arg2 uintptr) *glib.Variant {
			819	+	cbFn := *SetMappingVar
			820	+	return cbFn(arg0, arg1, arg2)
			821	+	}
			822	+	SetMappingVarRef = purego.NewCallback(fcb)
			823	+	glib.SaveCallback(SetMappingVarPtr, SetMappingVarRef)
			824	+	}
			825	+	}
			826	+
			827	+	var DestroyVarRef uintptr
			828	+	if DestroyVar != nil {
			829	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			830	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			831	+	DestroyVarRef = cbRefPtr
			832	+	} else {
			833	+	fcb := func(arg0 uintptr) {
			834	+	cbFn := *DestroyVar
			835	+	cbFn(arg0)
			836	+	}
			837	+	DestroyVarRef = purego.NewCallback(fcb)
			838	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			839	+	}
			840	+	}
			841	+
			842	+	xSettingsBindWithMapping(x.GoPointer(), KeyVar, ObjectVar.GoPointer(), PropertyVar, FlagsVar, GetMappingVarRef, SetMappingVarRef, UserDataVar, DestroyVarRef)
797			843
798		}	844		}
799			845

@@ -1085,7 +1131,22 @@ var xSettingsGetMapped func(uintptr, string, uintptr, uintptr) uintptr
1085		// just as any other value would be.	1131		// just as any other value would be.
1086		func (x Settings) GetMapped(KeyVar string, MappingVar SettingsGetMapping, UserDataVar uintptr) uintptr {	1132		func (x Settings) GetMapped(KeyVar string, MappingVar SettingsGetMapping, UserDataVar uintptr) uintptr {
1087			1133
1088	-	cret := xSettingsGetMapped(x.GoPointer(), KeyVar, glib.NewCallback(MappingVar), UserDataVar)	1134	+	var MappingVarRef uintptr
			1135	+	if MappingVar != nil {
			1136	+	MappingVarPtr := uintptr(unsafe.Pointer(MappingVar))
			1137	+	if cbRefPtr, ok := glib.GetCallback(MappingVarPtr); ok {
			1138	+	MappingVarRef = cbRefPtr
			1139	+	} else {
			1140	+	fcb := func(arg0 glib.Variant, arg1 uintptr, arg2 uintptr) bool {
			1141	+	cbFn := *MappingVar
			1142	+	return cbFn(arg0, arg1, arg2)
			1143	+	}
			1144	+	MappingVarRef = purego.NewCallback(fcb)
			1145	+	glib.SaveCallback(MappingVarPtr, MappingVarRef)
			1146	+	}
			1147	+	}
			1148	+
			1149	+	cret := xSettingsGetMapped(x.GoPointer(), KeyVar, MappingVarRef, UserDataVar)
1089		return cret	1150		return cret
1090		}	1151		}
1091			1152

@@ -1492,7 +1553,7 @@ func (x *Settings) GetPropertyHasUnapplied() bool {
1492		func (x *Settings) SetPropertyPath(value string) {	1553		func (x *Settings) SetPropertyPath(value string) {
1493		var v gobject.Value	1554		var v gobject.Value
1494		v.Init(gobject.TypeStringVal)	1555		v.Init(gobject.TypeStringVal)
1495	-	v.SetString(value)	1556	+	v.SetString(&value)
1496		x.SetProperty("path", &v)	1557		x.SetProperty("path", &v)
1497		}	1558		}
1498			1559

@@ -1517,7 +1578,7 @@ func (x *Settings) GetPropertyPath() string {
1517		func (x *Settings) SetPropertySchema(value string) {	1578		func (x *Settings) SetPropertySchema(value string) {
1518		var v gobject.Value	1579		var v gobject.Value
1519		v.Init(gobject.TypeStringVal)	1580		v.Init(gobject.TypeStringVal)
1520	-	v.SetString(value)	1581	+	v.SetString(&value)
1521		x.SetProperty("schema", &v)	1582		x.SetProperty("schema", &v)
1522		}	1583		}
1523			1584

@@ -1543,7 +1604,7 @@ func (x *Settings) GetPropertySchema() string {
1543		func (x *Settings) SetPropertySchemaId(value string) {	1604		func (x *Settings) SetPropertySchemaId(value string) {
1544		var v gobject.Value	1605		var v gobject.Value
1545		v.Init(gobject.TypeStringVal)	1606		v.Init(gobject.TypeStringVal)
1546	-	v.SetString(value)	1607	+	v.SetString(&value)
1547		x.SetProperty("schema-id", &v)	1608		x.SetProperty("schema-id", &v)
1548		}	1609		}
1549			1610

@@ -1652,6 +1713,28 @@ func (x Settings) ConnectChanged(cb func(Settings, string)) uint32 {
1652		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)	1713		return gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
1653		}	1714		}
1654			1715
			1716	+	// ConnectChangedWithDetail connects to the "changed" signal with a detail string.
			1717	+	// The detail is appended as "changed::<detail>".
			1718	+	func (x Settings) ConnectChangedWithDetail(detail string, cb func(Settings, string)) uint32 {
			1719	+	cbPtr := uintptr(unsafe.Pointer(cb))
			1720	+	signalName := fmt.Sprintf("changed::%s", detail)
			1721	+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
			1722	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			1723	+	}
			1724	+
			1725	+	fcb := func(clsPtr uintptr, KeyVarp string) {
			1726	+	fa := Settings{}
			1727	+	fa.Ptr = clsPtr
			1728	+	cbFn := *cb
			1729	+
			1730	+	cbFn(fa, KeyVarp)
			1731	+
			1732	+	}
			1733	+	cbRefPtr := purego.NewCallback(fcb)
			1734	+	glib.SaveCallback(cbPtr, cbRefPtr)
			1735	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			1736	+	}
			1737	+
1655		// Emitted once per writability change event that affects this settings object.	1738		// Emitted once per writability change event that affects this settings object.
1656		//	1739		//
1657		// You should connect	1740		// You should connect

@@ -1717,6 +1800,28 @@ func (x Settings) ConnectWritableChanged(cb func(Settings, string)) uint32 {
1717		return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)	1800		return gobject.SignalConnect(x.GoPointer(), "writable-changed", cbRefPtr)
1718		}	1801		}
1719			1802
			1803	+	// ConnectWritableChangedWithDetail connects to the "writable-changed" signal with a detail string.
			1804	+	// The detail is appended as "writable-changed::<detail>".
			1805	+	func (x Settings) ConnectWritableChangedWithDetail(detail string, cb func(Settings, string)) uint32 {
			1806	+	cbPtr := uintptr(unsafe.Pointer(cb))
			1807	+	signalName := fmt.Sprintf("writable-changed::%s", detail)
			1808	+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
			1809	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			1810	+	}
			1811	+
			1812	+	fcb := func(clsPtr uintptr, KeyVarp string) {
			1813	+	fa := Settings{}
			1814	+	fa.Ptr = clsPtr
			1815	+	cbFn := *cb
			1816	+
			1817	+	cbFn(fa, KeyVarp)
			1818	+
			1819	+	}
			1820	+	cbRefPtr := purego.NewCallback(fcb)
			1821	+	glib.SaveCallback(cbPtr, cbRefPtr)
			1822	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			1823	+	}
			1824	+
1720		var xSettingsListRelocatableSchemas func() []string	1825		var xSettingsListRelocatableSchemas func() []string
1721			1826
1722		// Deprecated.	1827		// Deprecated.

M v4/gio/gsettingsbackend.go +3 -3


@@ -318,7 +318,7 @@ const (
318		SETTINGS_BACKEND_EXTENSION_POINT_NAME string = "gsettings-backend"	318		SETTINGS_BACKEND_EXTENSION_POINT_NAME string = "gsettings-backend"
319		)	319		)
320			320
321	-	var xKeyfileSettingsBackendNew func(string, string, string) uintptr	321	+	var xKeyfileSettingsBackendNew func(string, string, uintptr) uintptr
322			322
323		// Creates a keyfile-backed [class@Gio.SettingsBackend].	323		// Creates a keyfile-backed [class@Gio.SettingsBackend].
324		//	324		//

@@ -369,10 +369,10 @@ var xKeyfileSettingsBackendNew func(string, string, string) uintptr
369		// the directory specified by the `GKeyfileSettingsBackend:defaults-dir`	369		// the directory specified by the `GKeyfileSettingsBackend:defaults-dir`
370		// property, and a list of locked keys from a text file with the name `locks` in	370		// property, and a list of locked keys from a text file with the name `locks` in
371		// the same location.	371		// the same location.
372	-	func KeyfileSettingsBackendNew(FilenameVar string, RootPathVar string, RootGroupVar string) *SettingsBackend {	372	+	func KeyfileSettingsBackendNew(FilenameVar string, RootPathVar string, RootGroupVar string) SettingsBackend {
373		var cls *SettingsBackend	373		var cls *SettingsBackend
374			374
375	-	cret := xKeyfileSettingsBackendNew(FilenameVar, RootPathVar, RootGroupVar)	375	+	cret := xKeyfileSettingsBackendNew(FilenameVar, RootPathVar, core.NullableStringToPtr(RootGroupVar))
376			376
377		if cret == 0 {	377		if cret == 0 {
378		return nil	378		return nil

M v4/gio/gsimpleaction.go +1 -1


@@ -155,7 +155,7 @@ func (x *SimpleAction) GetPropertyEnabled() bool {
155		func (x *SimpleAction) SetPropertyName(value string) {	155		func (x *SimpleAction) SetPropertyName(value string) {
156		var v gobject.Value	156		var v gobject.Value
157		v.Init(gobject.TypeStringVal)	157		v.Init(gobject.TypeStringVal)
158	-	v.SetString(value)	158	+	v.SetString(&value)
159		x.SetProperty("name", &v)	159		x.SetProperty("name", &v)
160		}	160		}
161			161

M v4/gio/gsimpleasyncresult.go +144 -9


@@ -27,7 +27,22 @@ var xSimpleAsyncReportErrorInIdle func(uintptr, uintptr, uintptr, glib.Quark, in
27		// information.	27		// information.
28		func SimpleAsyncReportErrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {	28		func SimpleAsyncReportErrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
29			29
30	-	xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)	30	+	var CallbackVarRef uintptr
			31	+	if CallbackVar != nil {
			32	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			33	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			34	+	CallbackVarRef = cbRefPtr
			35	+	} else {
			36	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			37	+	cbFn := *CallbackVar
			38	+	cbFn(arg0, arg1, arg2)
			39	+	}
			40	+	CallbackVarRef = purego.NewCallback(fcb)
			41	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			42	+	}
			43	+	}
			44	+
			45	+	xSimpleAsyncReportErrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
31			46
32		}	47		}
33			48

@@ -38,7 +53,22 @@ var xSimpleAsyncReportGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Error)
38		// than building a new one.	53		// than building a new one.
39		func SimpleAsyncReportGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {	54		func SimpleAsyncReportGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
40			55
41	-	xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)	56	+	var CallbackVarRef uintptr
			57	+	if CallbackVar != nil {
			58	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			59	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			60	+	CallbackVarRef = cbRefPtr
			61	+	} else {
			62	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			63	+	cbFn := *CallbackVar
			64	+	cbFn(arg0, arg1, arg2)
			65	+	}
			66	+	CallbackVarRef = purego.NewCallback(fcb)
			67	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			68	+	}
			69	+	}
			70	+
			71	+	xSimpleAsyncReportGerrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
42			72
43		}	73		}
44			74

@@ -49,7 +79,22 @@ var xSimpleAsyncReportTakeGerrorInIdle func(uintptr, uintptr, uintptr, *glib.Err
49		// ownership of @error, so the caller does not have to free it any more.	79		// ownership of @error, so the caller does not have to free it any more.
50		func SimpleAsyncReportTakeGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {	80		func SimpleAsyncReportTakeGerrorInIdle(ObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar *glib.Error) {
51			81
52	-	xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)	82	+	var CallbackVarRef uintptr
			83	+	if CallbackVar != nil {
			84	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			85	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			86	+	CallbackVarRef = cbRefPtr
			87	+	} else {
			88	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			89	+	cbFn := *CallbackVar
			90	+	cbFn(arg0, arg1, arg2)
			91	+	}
			92	+	CallbackVarRef = purego.NewCallback(fcb)
			93	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			94	+	}
			95	+	}
			96	+
			97	+	xSimpleAsyncReportTakeGerrorInIdle(ObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
53			98
54		}	99		}
55			100

@@ -257,7 +302,22 @@ var xNewSimpleAsyncResult func(uintptr, uintptr, uintptr, uintptr) uintptr
257		func NewSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {	302		func NewSimpleAsyncResult(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, SourceTagVar uintptr) *SimpleAsyncResult {
258		var cls *SimpleAsyncResult	303		var cls *SimpleAsyncResult
259			304
260	-	cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, SourceTagVar)	305	+	var CallbackVarRef uintptr
			306	+	if CallbackVar != nil {
			307	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			308	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			309	+	CallbackVarRef = cbRefPtr
			310	+	} else {
			311	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			312	+	cbFn := *CallbackVar
			313	+	cbFn(arg0, arg1, arg2)
			314	+	}
			315	+	CallbackVarRef = purego.NewCallback(fcb)
			316	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			317	+	}
			318	+	}
			319	+
			320	+	cret := xNewSimpleAsyncResult(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, SourceTagVar)
261			321
262		if cret == 0 {	322		if cret == 0 {
263		return nil	323		return nil

@@ -273,7 +333,22 @@ var xNewSimpleAsyncResultError func(uintptr, uintptr, uintptr, glib.Quark, int,
273		func NewSimpleAsyncResultError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {	333		func NewSimpleAsyncResultError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) *SimpleAsyncResult {
274		var cls *SimpleAsyncResult	334		var cls *SimpleAsyncResult
275			335
276	-	cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)	336	+	var CallbackVarRef uintptr
			337	+	if CallbackVar != nil {
			338	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			339	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			340	+	CallbackVarRef = cbRefPtr
			341	+	} else {
			342	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			343	+	cbFn := *CallbackVar
			344	+	cbFn(arg0, arg1, arg2)
			345	+	}
			346	+	CallbackVarRef = purego.NewCallback(fcb)
			347	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			348	+	}
			349	+	}
			350	+
			351	+	cret := xNewSimpleAsyncResultError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, DomainVar, CodeVar, FormatVar, varArgs...)
277			352
278		if cret == 0 {	353		if cret == 0 {
279		return nil	354		return nil

@@ -289,7 +364,22 @@ var xNewSimpleAsyncResultFromError func(uintptr, uintptr, uintptr, *glib.Error)
289		func NewSimpleAsyncResultFromError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {	364		func NewSimpleAsyncResultFromError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {
290		var cls *SimpleAsyncResult	365		var cls *SimpleAsyncResult
291			366
292	-	cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)	367	+	var CallbackVarRef uintptr
			368	+	if CallbackVar != nil {
			369	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			370	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			371	+	CallbackVarRef = cbRefPtr
			372	+	} else {
			373	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			374	+	cbFn := *CallbackVar
			375	+	cbFn(arg0, arg1, arg2)
			376	+	}
			377	+	CallbackVarRef = purego.NewCallback(fcb)
			378	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			379	+	}
			380	+	}
			381	+
			382	+	cret := xNewSimpleAsyncResultFromError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
293			383
294		if cret == 0 {	384		if cret == 0 {
295		return nil	385		return nil

@@ -306,7 +396,22 @@ var xNewSimpleAsyncResultTakeError func(uintptr, uintptr, uintptr, *glib.Error)
306		func NewSimpleAsyncResultTakeError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {	396		func NewSimpleAsyncResultTakeError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, UserDataVar uintptr, ErrorVar glib.Error) SimpleAsyncResult {
307		var cls *SimpleAsyncResult	397		var cls *SimpleAsyncResult
308			398
309	-	cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar, ErrorVar)	399	+	var CallbackVarRef uintptr
			400	+	if CallbackVar != nil {
			401	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			402	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			403	+	CallbackVarRef = cbRefPtr
			404	+	} else {
			405	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			406	+	cbFn := *CallbackVar
			407	+	cbFn(arg0, arg1, arg2)
			408	+	}
			409	+	CallbackVarRef = purego.NewCallback(fcb)
			410	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			411	+	}
			412	+	}
			413	+
			414	+	cret := xNewSimpleAsyncResultTakeError(SourceObjectVar.GoPointer(), CallbackVarRef, UserDataVar, ErrorVar)
310			415
311		if cret == 0 {	416		if cret == 0 {
312		return nil	417		return nil

@@ -411,7 +516,22 @@ var xSimpleAsyncResultRunInThread func(uintptr, uintptr, int, uintptr)
411		// is needed to run the job and report its completion.	516		// is needed to run the job and report its completion.
412		func (x SimpleAsyncResult) RunInThread(FuncVar SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {	517		func (x SimpleAsyncResult) RunInThread(FuncVar SimpleAsyncThreadFunc, IoPriorityVar int, CancellableVar *Cancellable) {
413			518
414	-	xSimpleAsyncResultRunInThread(x.GoPointer(), glib.NewCallback(FuncVar), IoPriorityVar, CancellableVar.GoPointer())	519	+	var FuncVarRef uintptr
			520	+	if FuncVar != nil {
			521	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			522	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			523	+	FuncVarRef = cbRefPtr
			524	+	} else {
			525	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			526	+	cbFn := *FuncVar
			527	+	cbFn(arg0, arg1, arg2)
			528	+	}
			529	+	FuncVarRef = purego.NewCallback(fcb)
			530	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			531	+	}
			532	+	}
			533	+
			534	+	xSimpleAsyncResultRunInThread(x.GoPointer(), FuncVarRef, IoPriorityVar, CancellableVar.GoPointer())
415			535
416		}	536		}
417			537

@@ -493,7 +613,22 @@ var xSimpleAsyncResultSetOpResGpointer func(uintptr, uintptr, uintptr)
493		// Sets the operation result within the asynchronous result to a pointer.	613		// Sets the operation result within the asynchronous result to a pointer.
494		func (x SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar glib.DestroyNotify) {	614		func (x SimpleAsyncResult) SetOpResGpointer(OpResVar uintptr, DestroyOpResVar glib.DestroyNotify) {
495			615
496	-	xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, glib.NewCallback(DestroyOpResVar))	616	+	var DestroyOpResVarRef uintptr
			617	+	if DestroyOpResVar != nil {
			618	+	DestroyOpResVarPtr := uintptr(unsafe.Pointer(DestroyOpResVar))
			619	+	if cbRefPtr, ok := glib.GetCallback(DestroyOpResVarPtr); ok {
			620	+	DestroyOpResVarRef = cbRefPtr
			621	+	} else {
			622	+	fcb := func(arg0 uintptr) {
			623	+	cbFn := *DestroyOpResVar
			624	+	cbFn(arg0)
			625	+	}
			626	+	DestroyOpResVarRef = purego.NewCallback(fcb)
			627	+	glib.SaveCallback(DestroyOpResVarPtr, DestroyOpResVarRef)
			628	+	}
			629	+	}
			630	+
			631	+	xSimpleAsyncResultSetOpResGpointer(x.GoPointer(), OpResVar, DestroyOpResVarRef)
497			632
498		}	633		}
499			634

M v4/gio/gsimpleproxyresolver.go +7 -7


@@ -179,7 +179,7 @@ func SimpleProxyResolverNewFromInternalPtr(ptr uintptr) *SimpleProxyResolver {
179		return cls	179		return cls
180		}	180		}
181			181
182	-	var xSimpleProxyResolverSetDefaultProxy func(uintptr, string)	182	+	var xSimpleProxyResolverSetDefaultProxy func(uintptr, uintptr)
183			183
184		// Sets the default proxy on @resolver, to be used for any URIs that	184		// Sets the default proxy on @resolver, to be used for any URIs that
185		// don't match #GSimpleProxyResolver:ignore-hosts or a proxy set	185		// don't match #GSimpleProxyResolver:ignore-hosts or a proxy set

@@ -188,9 +188,9 @@ var xSimpleProxyResolverSetDefaultProxy func(uintptr, string)
188		// If @default_proxy starts with "socks://",	188		// If @default_proxy starts with "socks://",
189		// #GSimpleProxyResolver will treat it as referring to all three of	189		// #GSimpleProxyResolver will treat it as referring to all three of
190		// the socks5, socks4a, and socks4 proxy types.	190		// the socks5, socks4a, and socks4 proxy types.
191	-	func (x *SimpleProxyResolver) SetDefaultProxy(DefaultProxyVar string) {	191	+	func (x SimpleProxyResolver) SetDefaultProxy(DefaultProxyVar string) {
192			192
193	-	xSimpleProxyResolverSetDefaultProxy(x.GoPointer(), DefaultProxyVar)	193	+	xSimpleProxyResolverSetDefaultProxy(x.GoPointer(), core.NullableStringToPtr(DefaultProxyVar))
194			194
195		}	195		}
196			196

@@ -244,7 +244,7 @@ func (c *SimpleProxyResolver) SetGoPointer(ptr uintptr) {
244		func (x *SimpleProxyResolver) SetPropertyDefaultProxy(value string) {	244		func (x *SimpleProxyResolver) SetPropertyDefaultProxy(value string) {
245		var v gobject.Value	245		var v gobject.Value
246		v.Init(gobject.TypeStringVal)	246		v.Init(gobject.TypeStringVal)
247	-	v.SetString(value)	247	+	v.SetString(&value)
248		x.SetProperty("default-proxy", &v)	248		x.SetProperty("default-proxy", &v)
249		}	249		}
250			250

@@ -402,16 +402,16 @@ func (x *SimpleProxyResolver) LookupFinish(ResultVar AsyncResult) ([]string, err
402			402
403		}	403		}
404			404
405	-	var xSimpleProxyResolverNew func(string, []string) uintptr	405	+	var xSimpleProxyResolverNew func(uintptr, []string) uintptr
406			406
407		// Creates a new #GSimpleProxyResolver. See	407		// Creates a new #GSimpleProxyResolver. See
408		// #GSimpleProxyResolver:default-proxy and	408		// #GSimpleProxyResolver:default-proxy and
409		// #GSimpleProxyResolver:ignore-hosts for more details on how the	409		// #GSimpleProxyResolver:ignore-hosts for more details on how the
410		// arguments are interpreted.	410		// arguments are interpreted.
411	-	func SimpleProxyResolverNew(DefaultProxyVar string, IgnoreHostsVar []string) *ProxyResolverBase {	411	+	func SimpleProxyResolverNew(DefaultProxyVar string, IgnoreHostsVar []string) ProxyResolverBase {
412		var cls *ProxyResolverBase	412		var cls *ProxyResolverBase
413			413
414	-	cret := xSimpleProxyResolverNew(DefaultProxyVar, IgnoreHostsVar)	414	+	cret := xSimpleProxyResolverNew(core.NullableStringToPtr(DefaultProxyVar), IgnoreHostsVar)
415			415
416		if cret == 0 {	416		if cret == 0 {
417		return nil	417		return nil

M v4/gio/gsocket.go +12 -12


@@ -987,7 +987,7 @@ func (x *Socket) IsConnected() bool {
987		return cret	987		return cret
988		}	988		}
989			989
990	-	var xSocketJoinMulticastGroup func(uintptr, uintptr, bool, string, **glib.Error) bool	990	+	var xSocketJoinMulticastGroup func(uintptr, uintptr, bool, uintptr, **glib.Error) bool
991			991
992		// Registers @socket to receive multicast messages sent to @group.	992		// Registers @socket to receive multicast messages sent to @group.
993		// @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have	993		// @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have

@@ -1003,10 +1003,10 @@ var xSocketJoinMulticastGroup func(uintptr, uintptr, bool, string, **glib.Error)
1003		//	1003		//
1004		// To bind to a given source-specific multicast address, use	1004		// To bind to a given source-specific multicast address, use
1005		// g_socket_join_multicast_group_ssm() instead.	1005		// g_socket_join_multicast_group_ssm() instead.
1006	-	func (x Socket) JoinMulticastGroup(GroupVar InetAddress, SourceSpecificVar bool, IfaceVar string) (bool, error) {	1006	+	func (x Socket) JoinMulticastGroup(GroupVar InetAddress, SourceSpecificVar bool, IfaceVar *string) (bool, error) {
1007		var cerr *glib.Error	1007		var cerr *glib.Error
1008			1008
1009	-	cret := xSocketJoinMulticastGroup(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar, IfaceVar, &cerr)	1009	+	cret := xSocketJoinMulticastGroup(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar, core.NullableStringToPtr(IfaceVar), &cerr)
1010		if cerr == nil {	1010		if cerr == nil {
1011		return cret, nil	1011		return cret, nil
1012		}	1012		}

@@ -1014,7 +1014,7 @@ func (x Socket) JoinMulticastGroup(GroupVar InetAddress, SourceSpecificVar boo
1014			1014
1015		}	1015		}
1016			1016
1017	-	var xSocketJoinMulticastGroupSsm func(uintptr, uintptr, uintptr, string, **glib.Error) bool	1017	+	var xSocketJoinMulticastGroupSsm func(uintptr, uintptr, uintptr, uintptr, **glib.Error) bool
1018			1018
1019		// Registers @socket to receive multicast messages sent to @group.	1019		// Registers @socket to receive multicast messages sent to @group.
1020		// @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have	1020		// @socket must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have

@@ -1031,10 +1031,10 @@ var xSocketJoinMulticastGroupSsm func(uintptr, uintptr, uintptr, string, **glib.
1031		// Note that this function can be called multiple times for the same	1031		// Note that this function can be called multiple times for the same
1032		// @group with different @source_specific in order to receive multicast	1032		// @group with different @source_specific in order to receive multicast
1033		// packets from more than one source.	1033		// packets from more than one source.
1034	-	func (x Socket) JoinMulticastGroupSsm(GroupVar InetAddress, SourceSpecificVar *InetAddress, IfaceVar string) (bool, error) {	1034	+	func (x Socket) JoinMulticastGroupSsm(GroupVar InetAddress, SourceSpecificVar InetAddress, IfaceVar string) (bool, error) {
1035		var cerr *glib.Error	1035		var cerr *glib.Error
1036			1036
1037	-	cret := xSocketJoinMulticastGroupSsm(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar.GoPointer(), IfaceVar, &cerr)	1037	+	cret := xSocketJoinMulticastGroupSsm(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar.GoPointer(), core.NullableStringToPtr(IfaceVar), &cerr)
1038		if cerr == nil {	1038		if cerr == nil {
1039		return cret, nil	1039		return cret, nil
1040		}	1040		}

@@ -1042,7 +1042,7 @@ func (x Socket) JoinMulticastGroupSsm(GroupVar InetAddress, SourceSpecificVar
1042			1042
1043		}	1043		}
1044			1044
1045	-	var xSocketLeaveMulticastGroup func(uintptr, uintptr, bool, string, **glib.Error) bool	1045	+	var xSocketLeaveMulticastGroup func(uintptr, uintptr, bool, uintptr, **glib.Error) bool
1046			1046
1047		// Removes @socket from the multicast group defined by @group, @iface,	1047		// Removes @socket from the multicast group defined by @group, @iface,
1048		// and @source_specific (which must all have the same values they had	1048		// and @source_specific (which must all have the same values they had

@@ -1053,10 +1053,10 @@ var xSocketLeaveMulticastGroup func(uintptr, uintptr, bool, string, **glib.Error
1053		//	1053		//
1054		// To unbind to a given source-specific multicast address, use	1054		// To unbind to a given source-specific multicast address, use
1055		// g_socket_leave_multicast_group_ssm() instead.	1055		// g_socket_leave_multicast_group_ssm() instead.
1056	-	func (x Socket) LeaveMulticastGroup(GroupVar InetAddress, SourceSpecificVar bool, IfaceVar string) (bool, error) {	1056	+	func (x Socket) LeaveMulticastGroup(GroupVar InetAddress, SourceSpecificVar bool, IfaceVar *string) (bool, error) {
1057		var cerr *glib.Error	1057		var cerr *glib.Error
1058			1058
1059	-	cret := xSocketLeaveMulticastGroup(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar, IfaceVar, &cerr)	1059	+	cret := xSocketLeaveMulticastGroup(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar, core.NullableStringToPtr(IfaceVar), &cerr)
1060		if cerr == nil {	1060		if cerr == nil {
1061		return cret, nil	1061		return cret, nil
1062		}	1062		}

@@ -1064,7 +1064,7 @@ func (x Socket) LeaveMulticastGroup(GroupVar InetAddress, SourceSpecificVar bo
1064			1064
1065		}	1065		}
1066			1066
1067	-	var xSocketLeaveMulticastGroupSsm func(uintptr, uintptr, uintptr, string, **glib.Error) bool	1067	+	var xSocketLeaveMulticastGroupSsm func(uintptr, uintptr, uintptr, uintptr, **glib.Error) bool
1068			1068
1069		// Removes @socket from the multicast group defined by @group, @iface,	1069		// Removes @socket from the multicast group defined by @group, @iface,
1070		// and @source_specific (which must all have the same values they had	1070		// and @source_specific (which must all have the same values they had

@@ -1072,10 +1072,10 @@ var xSocketLeaveMulticastGroupSsm func(uintptr, uintptr, uintptr, string, **glib
1072		//	1072		//
1073		// @socket remains bound to its address and port, and can still receive	1073		// @socket remains bound to its address and port, and can still receive
1074		// unicast messages after calling this.	1074		// unicast messages after calling this.
1075	-	func (x Socket) LeaveMulticastGroupSsm(GroupVar InetAddress, SourceSpecificVar *InetAddress, IfaceVar string) (bool, error) {	1075	+	func (x Socket) LeaveMulticastGroupSsm(GroupVar InetAddress, SourceSpecificVar InetAddress, IfaceVar string) (bool, error) {
1076		var cerr *glib.Error	1076		var cerr *glib.Error
1077			1077
1078	-	cret := xSocketLeaveMulticastGroupSsm(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar.GoPointer(), IfaceVar, &cerr)	1078	+	cret := xSocketLeaveMulticastGroupSsm(x.GoPointer(), GroupVar.GoPointer(), SourceSpecificVar.GoPointer(), core.NullableStringToPtr(IfaceVar), &cerr)
1079		if cerr == nil {	1079		if cerr == nil {
1080		return cret, nil	1080		return cret, nil
1081		}	1081		}

M v4/gio/gsocketaddressenumerator.go +16 -1


@@ -197,7 +197,22 @@ var xSocketAddressEnumeratorNextAsync func(uintptr, uintptr, uintptr, uintptr)
197		// It is an error to call this multiple times before the previous callback has finished.	197		// It is an error to call this multiple times before the previous callback has finished.
198		func (x SocketAddressEnumerator) NextAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	198		func (x SocketAddressEnumerator) NextAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
199			199
200	-	xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	200	+	var CallbackVarRef uintptr
			201	+	if CallbackVar != nil {
			202	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			203	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			204	+	CallbackVarRef = cbRefPtr
			205	+	} else {
			206	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			207	+	cbFn := *CallbackVar
			208	+	cbFn(arg0, arg1, arg2)
			209	+	}
			210	+	CallbackVarRef = purego.NewCallback(fcb)
			211	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			212	+	}
			213	+	}
			214	+
			215	+	xSocketAddressEnumeratorNextAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
201			216
202		}	217		}
203			218

M v4/gio/gsocketclient.go +64 -4


@@ -283,7 +283,22 @@ var xSocketClientConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintptr)
283		// the result of the operation.	283		// the result of the operation.
284		func (x SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	284		func (x SocketClient) ConnectAsync(ConnectableVar SocketConnectable, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
285			285
286	-	xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	286	+	var CallbackVarRef uintptr
			287	+	if CallbackVar != nil {
			288	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			289	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			290	+	CallbackVarRef = cbRefPtr
			291	+	} else {
			292	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			293	+	cbFn := *CallbackVar
			294	+	cbFn(arg0, arg1, arg2)
			295	+	}
			296	+	CallbackVarRef = purego.NewCallback(fcb)
			297	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			298	+	}
			299	+	}
			300	+
			301	+	xSocketClientConnectAsync(x.GoPointer(), ConnectableVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
287			302
288		}	303		}
289			304

@@ -367,7 +382,22 @@ var xSocketClientConnectToHostAsync func(uintptr, string, uint16, uintptr, uintp
367		// the result of the operation.	382		// the result of the operation.
368		func (x SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	383		func (x SocketClient) ConnectToHostAsync(HostAndPortVar string, DefaultPortVar uint16, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
369			384
370	-	xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	385	+	var CallbackVarRef uintptr
			386	+	if CallbackVar != nil {
			387	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			388	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			389	+	CallbackVarRef = cbRefPtr
			390	+	} else {
			391	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			392	+	cbFn := *CallbackVar
			393	+	cbFn(arg0, arg1, arg2)
			394	+	}
			395	+	CallbackVarRef = purego.NewCallback(fcb)
			396	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			397	+	}
			398	+	}
			399	+
			400	+	xSocketClientConnectToHostAsync(x.GoPointer(), HostAndPortVar, DefaultPortVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
371			401
372		}	402		}
373			403

@@ -432,7 +462,22 @@ var xSocketClientConnectToServiceAsync func(uintptr, string, string, uintptr, ui
432		// g_socket_client_connect_to_service().	462		// g_socket_client_connect_to_service().
433		func (x SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	463		func (x SocketClient) ConnectToServiceAsync(DomainVar string, ServiceVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
434			464
435	-	xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	465	+	var CallbackVarRef uintptr
			466	+	if CallbackVar != nil {
			467	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			468	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			469	+	CallbackVarRef = cbRefPtr
			470	+	} else {
			471	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			472	+	cbFn := *CallbackVar
			473	+	cbFn(arg0, arg1, arg2)
			474	+	}
			475	+	CallbackVarRef = purego.NewCallback(fcb)
			476	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			477	+	}
			478	+	}
			479	+
			480	+	xSocketClientConnectToServiceAsync(x.GoPointer(), DomainVar, ServiceVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
436			481
437		}	482		}
438			483

@@ -507,7 +552,22 @@ var xSocketClientConnectToUriAsync func(uintptr, string, uint16, uintptr, uintpt
507		// the result of the operation.	552		// the result of the operation.
508		func (x SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	553		func (x SocketClient) ConnectToUriAsync(UriVar string, DefaultPortVar uint16, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
509			554
510	-	xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	555	+	var CallbackVarRef uintptr
			556	+	if CallbackVar != nil {
			557	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			558	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			559	+	CallbackVarRef = cbRefPtr
			560	+	} else {
			561	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			562	+	cbFn := *CallbackVar
			563	+	cbFn(arg0, arg1, arg2)
			564	+	}
			565	+	CallbackVarRef = purego.NewCallback(fcb)
			566	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			567	+	}
			568	+	}
			569	+
			570	+	xSocketClientConnectToUriAsync(x.GoPointer(), UriVar, DefaultPortVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
511			571
512		}	572		}
513			573

M v4/gio/gsocketconnection.go +16 -1


@@ -240,7 +240,22 @@ var xSocketConnectionConnectAsync func(uintptr, uintptr, uintptr, uintptr, uintp
240		// Use g_socket_connection_connect_finish() to retrieve the result.	240		// Use g_socket_connection_connect_finish() to retrieve the result.
241		func (x SocketConnection) ConnectAsync(AddressVar SocketAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	241		func (x SocketConnection) ConnectAsync(AddressVar SocketAddress, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
242			242
243	-	xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	243	+	var CallbackVarRef uintptr
			244	+	if CallbackVar != nil {
			245	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			246	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			247	+	CallbackVarRef = cbRefPtr
			248	+	} else {
			249	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			250	+	cbFn := *CallbackVar
			251	+	cbFn(arg0, arg1, arg2)
			252	+	}
			253	+	CallbackVarRef = purego.NewCallback(fcb)
			254	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			255	+	}
			256	+	}
			257	+
			258	+	xSocketConnectionConnectAsync(x.GoPointer(), AddressVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
244			259
245		}	260		}
246			261

M v4/gio/gsocketlistener.go +32 -2


@@ -297,7 +297,22 @@ var xSocketListenerAcceptAsync func(uintptr, uintptr, uintptr, uintptr)
297		// to get the result of the operation.	297		// to get the result of the operation.
298		func (x SocketListener) AcceptAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	298		func (x SocketListener) AcceptAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
299			299
300	-	xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	300	+	var CallbackVarRef uintptr
			301	+	if CallbackVar != nil {
			302	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			303	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			304	+	CallbackVarRef = cbRefPtr
			305	+	} else {
			306	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			307	+	cbFn := *CallbackVar
			308	+	cbFn(arg0, arg1, arg2)
			309	+	}
			310	+	CallbackVarRef = purego.NewCallback(fcb)
			311	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			312	+	}
			313	+	}
			314	+
			315	+	xSocketListenerAcceptAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
301			316
302		}	317		}
303			318

@@ -365,7 +380,22 @@ var xSocketListenerAcceptSocketAsync func(uintptr, uintptr, uintptr, uintptr)
365		// to get the result of the operation.	380		// to get the result of the operation.
366		func (x SocketListener) AcceptSocketAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	381		func (x SocketListener) AcceptSocketAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
367			382
368	-	xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	383	+	var CallbackVarRef uintptr
			384	+	if CallbackVar != nil {
			385	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			386	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			387	+	CallbackVarRef = cbRefPtr
			388	+	} else {
			389	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			390	+	cbFn := *CallbackVar
			391	+	cbFn(arg0, arg1, arg2)
			392	+	}
			393	+	CallbackVarRef = purego.NewCallback(fcb)
			394	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			395	+	}
			396	+	}
			397	+
			398	+	xSocketListenerAcceptSocketAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
369			399
370		}	400		}
371			401

M v4/gio/gsubprocess.go +69 -9


@@ -195,7 +195,22 @@ var xSubprocessCommunicateAsync func(uintptr, *glib.Bytes, uintptr, uintptr, uin
195		// invocation with g_subprocess_communicate_finish().	195		// invocation with g_subprocess_communicate_finish().
196		func (x Subprocess) CommunicateAsync(StdinBufVar glib.Bytes, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	196		func (x Subprocess) CommunicateAsync(StdinBufVar glib.Bytes, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
197			197
198	-	xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	198	+	var CallbackVarRef uintptr
			199	+	if CallbackVar != nil {
			200	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			201	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			202	+	CallbackVarRef = cbRefPtr
			203	+	} else {
			204	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			205	+	cbFn := *CallbackVar
			206	+	cbFn(arg0, arg1, arg2)
			207	+	}
			208	+	CallbackVarRef = purego.NewCallback(fcb)
			209	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			210	+	}
			211	+	}
			212	+
			213	+	xSubprocessCommunicateAsync(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
199			214
200		}	215		}
201			216

@@ -213,17 +228,17 @@ func (x Subprocess) CommunicateFinish(ResultVar AsyncResult, StdoutBufVar *gli
213			228
214		}	229		}
215			230
216	-	var xSubprocessCommunicateUtf8 func(uintptr, string, uintptr, string, string, **glib.Error) bool	231	+	var xSubprocessCommunicateUtf8 func(uintptr, uintptr, uintptr, string, string, **glib.Error) bool
217			232
218		// Like g_subprocess_communicate(), but validates the output of the	233		// Like g_subprocess_communicate(), but validates the output of the
219		// process as UTF-8, and returns it as a regular NUL terminated string.	234		// process as UTF-8, and returns it as a regular NUL terminated string.
220		//	235		//
221		// On error, @stdout_buf and @stderr_buf will be set to undefined values and	236		// On error, @stdout_buf and @stderr_buf will be set to undefined values and
222		// should not be used.	237		// should not be used.
223	-	func (x Subprocess) CommunicateUtf8(StdinBufVar string, CancellableVar Cancellable, StdoutBufVar string, StderrBufVar string) (bool, error) {	238	+	func (x Subprocess) CommunicateUtf8(StdinBufVar string, CancellableVar Cancellable, StdoutBufVar string, StderrBufVar *string) (bool, error) {
224		var cerr *glib.Error	239		var cerr *glib.Error
225			240
226	-	cret := xSubprocessCommunicateUtf8(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), StdoutBufVar, StderrBufVar, &cerr)	241	+	cret := xSubprocessCommunicateUtf8(x.GoPointer(), core.NullableStringToPtr(StdinBufVar), CancellableVar.GoPointer(), StdoutBufVar, StderrBufVar, &cerr)
227		if cerr == nil {	242		if cerr == nil {
228		return cret, nil	243		return cret, nil
229		}	244		}

@@ -231,13 +246,28 @@ func (x Subprocess) CommunicateUtf8(StdinBufVar string, CancellableVar Cancell
231			246
232		}	247		}
233			248
234	-	var xSubprocessCommunicateUtf8Async func(uintptr, string, uintptr, uintptr, uintptr)	249	+	var xSubprocessCommunicateUtf8Async func(uintptr, uintptr, uintptr, uintptr, uintptr)
235			250
236		// Asynchronous version of g_subprocess_communicate_utf8(). Complete	251		// Asynchronous version of g_subprocess_communicate_utf8(). Complete
237		// invocation with g_subprocess_communicate_utf8_finish().	252		// invocation with g_subprocess_communicate_utf8_finish().
238	-	func (x Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	253	+	func (x Subprocess) CommunicateUtf8Async(StdinBufVar string, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
			254	+
			255	+	var CallbackVarRef uintptr
			256	+	if CallbackVar != nil {
			257	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			258	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			259	+	CallbackVarRef = cbRefPtr
			260	+	} else {
			261	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			262	+	cbFn := *CallbackVar
			263	+	cbFn(arg0, arg1, arg2)
			264	+	}
			265	+	CallbackVarRef = purego.NewCallback(fcb)
			266	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			267	+	}
			268	+	}
239			269
240	-	xSubprocessCommunicateUtf8Async(x.GoPointer(), StdinBufVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	270	+	xSubprocessCommunicateUtf8Async(x.GoPointer(), core.NullableStringToPtr(StdinBufVar), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
241			271
242		}	272		}
243			273

@@ -483,7 +513,22 @@ var xSubprocessWaitAsync func(uintptr, uintptr, uintptr, uintptr)
483		// This is the asynchronous version of g_subprocess_wait().	513		// This is the asynchronous version of g_subprocess_wait().
484		func (x Subprocess) WaitAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	514		func (x Subprocess) WaitAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485			515
486	-	xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	516	+	var CallbackVarRef uintptr
			517	+	if CallbackVar != nil {
			518	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			519	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			520	+	CallbackVarRef = cbRefPtr
			521	+	} else {
			522	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			523	+	cbFn := *CallbackVar
			524	+	cbFn(arg0, arg1, arg2)
			525	+	}
			526	+	CallbackVarRef = purego.NewCallback(fcb)
			527	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			528	+	}
			529	+	}
			530	+
			531	+	xSubprocessWaitAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
487			532
488		}	533		}
489			534

@@ -508,7 +553,22 @@ var xSubprocessWaitCheckAsync func(uintptr, uintptr, uintptr, uintptr)
508		// This is the asynchronous version of g_subprocess_wait_check().	553		// This is the asynchronous version of g_subprocess_wait_check().
509		func (x Subprocess) WaitCheckAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	554		func (x Subprocess) WaitCheckAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
510			555
511	-	xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	556	+	var CallbackVarRef uintptr
			557	+	if CallbackVar != nil {
			558	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			559	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			560	+	CallbackVarRef = cbRefPtr
			561	+	} else {
			562	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			563	+	cbFn := *CallbackVar
			564	+	cbFn(arg0, arg1, arg2)
			565	+	}
			566	+	CallbackVarRef = purego.NewCallback(fcb)
			567	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			568	+	}
			569	+	}
			570	+
			571	+	xSubprocessWaitCheckAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
512			572
513		}	573		}
514			574

M v4/gio/gsubprocesslauncher.go +42 -10

 package gio
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 	"github.com/jwijenbergh/puregotk/v4/glib"
 // Child setup functions are only available on UNIX.
 func (x *SubprocessLauncher) SetChildSetup(ChildSetupVar *glib.SpawnChildSetupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
-	xSubprocessLauncherSetChildSetup(x.GoPointer(), glib.NewCallback(ChildSetupVar), UserDataVar, glib.NewCallback(DestroyNotifyVar))
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := glib.GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	var DestroyNotifyVarRef uintptr
+	if DestroyNotifyVar != nil {
+		DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
+		if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
+			DestroyNotifyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyNotifyVar
+				cbFn(arg0)
+			}
+			DestroyNotifyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
+		}
+	}
+	xSubprocessLauncherSetChildSetup(x.GoPointer(), ChildSetupVarRef, UserDataVar, DestroyNotifyVarRef)
 }
 }
-var xSubprocessLauncherSetStderrFilePath func(uintptr, string)
+var xSubprocessLauncherSetStderrFilePath func(uintptr, uintptr)
 // Sets the file path to use as the stderr for spawned processes.
 //
 // if the launcher flags contain any flags directing stderr elsewhere.
 //
 // This feature is only available on UNIX.
-func (x *SubprocessLauncher) SetStderrFilePath(PathVar string) {
+func (x *SubprocessLauncher) SetStderrFilePath(PathVar *string) {
-	xSubprocessLauncherSetStderrFilePath(x.GoPointer(), PathVar)
+	xSubprocessLauncherSetStderrFilePath(x.GoPointer(), core.NullableStringToPtr(PathVar))
 }
-var xSubprocessLauncherSetStdinFilePath func(uintptr, string)
+var xSubprocessLauncherSetStdinFilePath func(uintptr, uintptr)
 // Sets the file path to use as the stdin for spawned processes.
 //
 // the launcher flags contain any flags directing stdin elsewhere.
 //
 // This feature is only available on UNIX.
-func (x *SubprocessLauncher) SetStdinFilePath(PathVar string) {
+func (x *SubprocessLauncher) SetStdinFilePath(PathVar *string) {
-	xSubprocessLauncherSetStdinFilePath(x.GoPointer(), PathVar)
+	xSubprocessLauncherSetStdinFilePath(x.GoPointer(), core.NullableStringToPtr(PathVar))
 }
-var xSubprocessLauncherSetStdoutFilePath func(uintptr, string)
+var xSubprocessLauncherSetStdoutFilePath func(uintptr, uintptr)
 // Sets the file path to use as the stdout for spawned processes.
 //
 // if the launcher flags contain any flags directing stdout elsewhere.
 //
 // This feature is only available on UNIX.
-func (x *SubprocessLauncher) SetStdoutFilePath(PathVar string) {
+func (x *SubprocessLauncher) SetStdoutFilePath(PathVar *string) {
-	xSubprocessLauncherSetStdoutFilePath(x.GoPointer(), PathVar)
+	xSubprocessLauncherSetStdoutFilePath(x.GoPointer(), core.NullableStringToPtr(PathVar))
 }

M v4/gio/gtask.go +134 -14


@@ -633,7 +633,22 @@ var xNewTask func(uintptr, uintptr, uintptr, uintptr) uintptr
633		func NewTask(SourceObjectVar gobject.Object, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr) Task {	633		func NewTask(SourceObjectVar gobject.Object, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr) Task {
634		var cls *Task	634		var cls *Task
635			635
636	-	cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar)	636	+	var CallbackVarRef uintptr
			637	+	if CallbackVar != nil {
			638	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			639	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			640	+	CallbackVarRef = cbRefPtr
			641	+	} else {
			642	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			643	+	cbFn := *CallbackVar
			644	+	cbFn(arg0, arg1, arg2)
			645	+	}
			646	+	CallbackVarRef = purego.NewCallback(fcb)
			647	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			648	+	}
			649	+	}
			650	+
			651	+	cret := xNewTask(SourceObjectVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, CallbackDataVar)
637			652
638		if cret == 0 {	653		if cret == 0 {
639		return nil	654		return nil

@@ -658,7 +673,22 @@ var xTaskAttachSource func(uintptr, *glib.Source, uintptr)
658		// This takes a reference on @task until @source is destroyed.	673		// This takes a reference on @task until @source is destroyed.
659		func (x Task) AttachSource(SourceVar glib.Source, CallbackVar *glib.SourceFunc) {	674		func (x Task) AttachSource(SourceVar glib.Source, CallbackVar *glib.SourceFunc) {
660			675
661	-	xTaskAttachSource(x.GoPointer(), SourceVar, glib.NewCallback(CallbackVar))	676	+	var CallbackVarRef uintptr
			677	+	if CallbackVar != nil {
			678	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			679	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			680	+	CallbackVarRef = cbRefPtr
			681	+	} else {
			682	+	fcb := func(arg0 uintptr) bool {
			683	+	cbFn := *CallbackVar
			684	+	return cbFn(arg0)
			685	+	}
			686	+	CallbackVarRef = purego.NewCallback(fcb)
			687	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			688	+	}
			689	+	}
			690	+
			691	+	xTaskAttachSource(x.GoPointer(), SourceVar, CallbackVarRef)
662			692
663		}	693		}
664			694

@@ -977,7 +1007,22 @@ var xTaskReturnPointer func(uintptr, uintptr, uintptr)
977		// reference on it.	1007		// reference on it.
978		func (x Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar glib.DestroyNotify) {	1008		func (x Task) ReturnPointer(ResultVar uintptr, ResultDestroyVar glib.DestroyNotify) {
979			1009
980	-	xTaskReturnPointer(x.GoPointer(), ResultVar, glib.NewCallbackNullable(ResultDestroyVar))	1010	+	var ResultDestroyVarRef uintptr
			1011	+	if ResultDestroyVar != nil {
			1012	+	ResultDestroyVarPtr := uintptr(unsafe.Pointer(ResultDestroyVar))
			1013	+	if cbRefPtr, ok := glib.GetCallback(ResultDestroyVarPtr); ok {
			1014	+	ResultDestroyVarRef = cbRefPtr
			1015	+	} else {
			1016	+	fcb := func(arg0 uintptr) {
			1017	+	cbFn := *ResultDestroyVar
			1018	+	cbFn(arg0)
			1019	+	}
			1020	+	ResultDestroyVarRef = purego.NewCallback(fcb)
			1021	+	glib.SaveCallback(ResultDestroyVarPtr, ResultDestroyVarRef)
			1022	+	}
			1023	+	}
			1024	+
			1025	+	xTaskReturnPointer(x.GoPointer(), ResultVar, ResultDestroyVarRef)
981			1026
982		}	1027		}
983			1028

@@ -1040,7 +1085,22 @@ var xTaskRunInThread func(uintptr, uintptr)
1040		// g_task_run_in_thread().	1085		// g_task_run_in_thread().
1041		func (x Task) RunInThread(TaskFuncVar TaskThreadFunc) {	1086		func (x Task) RunInThread(TaskFuncVar TaskThreadFunc) {
1042			1087
1043	-	xTaskRunInThread(x.GoPointer(), glib.NewCallback(TaskFuncVar))	1088	+	var TaskFuncVarRef uintptr
			1089	+	if TaskFuncVar != nil {
			1090	+	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
			1091	+	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
			1092	+	TaskFuncVarRef = cbRefPtr
			1093	+	} else {
			1094	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
			1095	+	cbFn := *TaskFuncVar
			1096	+	cbFn(arg0, arg1, arg2, arg3)
			1097	+	}
			1098	+	TaskFuncVarRef = purego.NewCallback(fcb)
			1099	+	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
			1100	+	}
			1101	+	}
			1102	+
			1103	+	xTaskRunInThread(x.GoPointer(), TaskFuncVarRef)
1044			1104
1045		}	1105		}
1046			1106

@@ -1064,7 +1124,22 @@ var xTaskRunInThreadSync func(uintptr, uintptr)
1064		// limited number of them at a time.	1124		// limited number of them at a time.
1065		func (x Task) RunInThreadSync(TaskFuncVar TaskThreadFunc) {	1125		func (x Task) RunInThreadSync(TaskFuncVar TaskThreadFunc) {
1066			1126
1067	-	xTaskRunInThreadSync(x.GoPointer(), glib.NewCallback(TaskFuncVar))	1127	+	var TaskFuncVarRef uintptr
			1128	+	if TaskFuncVar != nil {
			1129	+	TaskFuncVarPtr := uintptr(unsafe.Pointer(TaskFuncVar))
			1130	+	if cbRefPtr, ok := glib.GetCallback(TaskFuncVarPtr); ok {
			1131	+	TaskFuncVarRef = cbRefPtr
			1132	+	} else {
			1133	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr, arg3 uintptr) {
			1134	+	cbFn := *TaskFuncVar
			1135	+	cbFn(arg0, arg1, arg2, arg3)
			1136	+	}
			1137	+	TaskFuncVarRef = purego.NewCallback(fcb)
			1138	+	glib.SaveCallback(TaskFuncVarPtr, TaskFuncVarRef)
			1139	+	}
			1140	+	}
			1141	+
			1142	+	xTaskRunInThreadSync(x.GoPointer(), TaskFuncVarRef)
1068			1143
1069		}	1144		}
1070			1145

@@ -1090,7 +1165,7 @@ func (x *Task) SetCheckCancellable(CheckCancellableVar bool) {
1090			1165
1091		}	1166		}
1092			1167
1093	-	var xTaskSetName func(uintptr, string)	1168	+	var xTaskSetName func(uintptr, uintptr)
1094			1169
1095		// Sets @task’s name, used in debugging and profiling. The name defaults to	1170		// Sets @task’s name, used in debugging and profiling. The name defaults to
1096		// %NULL.	1171		// %NULL.

@@ -1101,9 +1176,9 @@ var xTaskSetName func(uintptr, string)
1101		//	1176		//
1102		// This function may only be called before the @task is first used in a thread	1177		// This function may only be called before the @task is first used in a thread
1103		// other than the one it was constructed in.	1178		// other than the one it was constructed in.
1104	-	func (x *Task) SetName(NameVar string) {	1179	+	func (x Task) SetName(NameVar string) {
1105			1180
1106	-	xTaskSetName(x.GoPointer(), NameVar)	1181	+	xTaskSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
1107			1182
1108		}	1183		}
1109			1184

@@ -1178,7 +1253,7 @@ func (x *Task) SetSourceTag(SourceTagVar uintptr) {
1178			1253
1179		}	1254		}
1180			1255
1181	-	var xTaskSetStaticName func(uintptr, string)	1256	+	var xTaskSetStaticName func(uintptr, uintptr)
1182			1257
1183		// Sets @task’s name, used in debugging and profiling.	1258		// Sets @task’s name, used in debugging and profiling.
1184		//	1259		//

@@ -1186,9 +1261,9 @@ var xTaskSetStaticName func(uintptr, string)
1186		//	1261		//
1187		// This function is called automatically by [method@Gio.Task.set_source_tag]	1262		// This function is called automatically by [method@Gio.Task.set_source_tag]
1188		// unless a name is set.	1263		// unless a name is set.
1189	-	func (x *Task) SetStaticName(NameVar string) {	1264	+	func (x Task) SetStaticName(NameVar string) {
1190			1265
1191	-	xTaskSetStaticName(x.GoPointer(), NameVar)	1266	+	xTaskSetStaticName(x.GoPointer(), core.NullableStringToPtr(NameVar))
1192			1267
1193		}	1268		}
1194			1269

@@ -1197,7 +1272,22 @@ var xTaskSetTaskData func(uintptr, uintptr, uintptr)
1197		// Sets @task's task data (freeing the existing task data, if any).	1272		// Sets @task's task data (freeing the existing task data, if any).
1198		func (x Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar glib.DestroyNotify) {	1273		func (x Task) SetTaskData(TaskDataVar uintptr, TaskDataDestroyVar glib.DestroyNotify) {
1199			1274
1200	-	xTaskSetTaskData(x.GoPointer(), TaskDataVar, glib.NewCallbackNullable(TaskDataDestroyVar))	1275	+	var TaskDataDestroyVarRef uintptr
			1276	+	if TaskDataDestroyVar != nil {
			1277	+	TaskDataDestroyVarPtr := uintptr(unsafe.Pointer(TaskDataDestroyVar))
			1278	+	if cbRefPtr, ok := glib.GetCallback(TaskDataDestroyVarPtr); ok {
			1279	+	TaskDataDestroyVarRef = cbRefPtr
			1280	+	} else {
			1281	+	fcb := func(arg0 uintptr) {
			1282	+	cbFn := *TaskDataDestroyVar
			1283	+	cbFn(arg0)
			1284	+	}
			1285	+	TaskDataDestroyVarRef = purego.NewCallback(fcb)
			1286	+	glib.SaveCallback(TaskDataDestroyVarPtr, TaskDataDestroyVarRef)
			1287	+	}
			1288	+	}
			1289	+
			1290	+	xTaskSetTaskData(x.GoPointer(), TaskDataVar, TaskDataDestroyVarRef)
1201			1291
1202		}	1292		}
1203			1293

@@ -1296,7 +1386,22 @@ var xTaskReportError func(uintptr, uintptr, uintptr, uintptr, *glib.Error)
1296		// See also g_task_report_new_error().	1386		// See also g_task_report_new_error().
1297		func TaskReportError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {	1387		func TaskReportError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, ErrorVar *glib.Error) {
1298			1388
1299	-	xTaskReportError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar, SourceTagVar, ErrorVar)	1389	+	var CallbackVarRef uintptr
			1390	+	if CallbackVar != nil {
			1391	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1392	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1393	+	CallbackVarRef = cbRefPtr
			1394	+	} else {
			1395	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1396	+	cbFn := *CallbackVar
			1397	+	cbFn(arg0, arg1, arg2)
			1398	+	}
			1399	+	CallbackVarRef = purego.NewCallback(fcb)
			1400	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1401	+	}
			1402	+	}
			1403	+
			1404	+	xTaskReportError(SourceObjectVar.GoPointer(), CallbackVarRef, CallbackDataVar, SourceTagVar, ErrorVar)
1300			1405
1301		}	1406		}
1302			1407

@@ -1313,7 +1418,22 @@ var xTaskReportNewError func(uintptr, uintptr, uintptr, uintptr, glib.Quark, int
1313		// See also g_task_report_error().	1418		// See also g_task_report_error().
1314		func TaskReportNewError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {	1419		func TaskReportNewError(SourceObjectVar gobject.Object, CallbackVar AsyncReadyCallback, CallbackDataVar uintptr, SourceTagVar uintptr, DomainVar glib.Quark, CodeVar int, FormatVar string, varArgs ...interface{}) {
1315			1420
1316	-	xTaskReportNewError(SourceObjectVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)	1421	+	var CallbackVarRef uintptr
			1422	+	if CallbackVar != nil {
			1423	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1424	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1425	+	CallbackVarRef = cbRefPtr
			1426	+	} else {
			1427	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			1428	+	cbFn := *CallbackVar
			1429	+	cbFn(arg0, arg1, arg2)
			1430	+	}
			1431	+	CallbackVarRef = purego.NewCallback(fcb)
			1432	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1433	+	}
			1434	+	}
			1435	+
			1436	+	xTaskReportNewError(SourceObjectVar.GoPointer(), CallbackVarRef, CallbackDataVar, SourceTagVar, DomainVar, CodeVar, FormatVar, varArgs...)
1317			1437
1318		}	1438		}
1319			1439

M v4/gio/gthemedicon.go +1 -1


@@ -157,7 +157,7 @@ func (c *ThemedIcon) SetGoPointer(ptr uintptr) {
157		func (x *ThemedIcon) SetPropertyName(value string) {	157		func (x *ThemedIcon) SetPropertyName(value string) {
158		var v gobject.Value	158		var v gobject.Value
159		v.Init(gobject.TypeStringVal)	159		v.Init(gobject.TypeStringVal)
160	-	v.SetString(value)	160	+	v.SetString(&value)
161		x.SetProperty("name", &v)	161		x.SetProperty("name", &v)
162		}	162		}
163			163

M v4/gio/gtlscertificate.go +11 -11


@@ -203,7 +203,7 @@ func NewTlsCertificateFromPem(DataVar string, LengthVar int) (*TlsCertificate, e
203			203
204		}	204		}
205			205
206	-	var xNewTlsCertificateFromPkcs11Uris func(string, string, **glib.Error) uintptr	206	+	var xNewTlsCertificateFromPkcs11Uris func(string, uintptr, **glib.Error) uintptr
207			207
208		// Creates a #GTlsCertificate from a	208		// Creates a #GTlsCertificate from a
209		// [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html) URI.	209		// [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html) URI.

@@ -232,11 +232,11 @@ var xNewTlsCertificateFromPkcs11Uris func(string, string, **glib.Error) uintptr
232		// @private_key_pkcs11_uri allows using a private key exposed under a different URI.	232		// @private_key_pkcs11_uri allows using a private key exposed under a different URI.
233		//	233		//
234		// Note that the private key is not accessed until usage and may fail or require a PIN later.	234		// Note that the private key is not accessed until usage and may fail or require a PIN later.
235	-	func NewTlsCertificateFromPkcs11Uris(Pkcs11UriVar string, PrivateKeyPkcs11UriVar string) (*TlsCertificate, error) {	235	+	func NewTlsCertificateFromPkcs11Uris(Pkcs11UriVar string, PrivateKeyPkcs11UriVar string) (TlsCertificate, error) {
236		var cls *TlsCertificate	236		var cls *TlsCertificate
237		var cerr *glib.Error	237		var cerr *glib.Error
238			238
239	-	cret := xNewTlsCertificateFromPkcs11Uris(Pkcs11UriVar, PrivateKeyPkcs11UriVar, &cerr)	239	+	cret := xNewTlsCertificateFromPkcs11Uris(Pkcs11UriVar, core.NullableStringToPtr(PrivateKeyPkcs11UriVar), &cerr)
240			240
241		if cret == 0 {	241		if cret == 0 {
242		return nil, cerr	242		return nil, cerr

@@ -250,7 +250,7 @@ func NewTlsCertificateFromPkcs11Uris(Pkcs11UriVar string, PrivateKeyPkcs11UriVar
250			250
251		}	251		}
252			252
253	-	var xNewTlsCertificateFromPkcs12 func([]byte, uint, string, **glib.Error) uintptr	253	+	var xNewTlsCertificateFromPkcs12 func([]byte, uint, uintptr, **glib.Error) uintptr
254			254
255		// Creates a #GTlsCertificate from the data in @data. It must contain	255		// Creates a #GTlsCertificate from the data in @data. It must contain
256		// a certificate and matching private key.	256		// a certificate and matching private key.

@@ -269,11 +269,11 @@ var xNewTlsCertificateFromPkcs12 func([]byte, uint, string, **glib.Error) uintpt
269		// %G_IO_ERROR_NOT_SUPPORTED.	269		// %G_IO_ERROR_NOT_SUPPORTED.
270		//	270		//
271		// Other parsing failures will error with %G_TLS_ERROR_BAD_CERTIFICATE.	271		// Other parsing failures will error with %G_TLS_ERROR_BAD_CERTIFICATE.
272	-	func NewTlsCertificateFromPkcs12(DataVar []byte, LengthVar uint, PasswordVar string) (*TlsCertificate, error) {	272	+	func NewTlsCertificateFromPkcs12(DataVar []byte, LengthVar uint, PasswordVar string) (TlsCertificate, error) {
273		var cls *TlsCertificate	273		var cls *TlsCertificate
274		var cerr *glib.Error	274		var cerr *glib.Error
275			275
276	-	cret := xNewTlsCertificateFromPkcs12(DataVar, LengthVar, PasswordVar, &cerr)	276	+	cret := xNewTlsCertificateFromPkcs12(DataVar, LengthVar, core.NullableStringToPtr(PasswordVar), &cerr)
277			277
278		if cret == 0 {	278		if cret == 0 {
279		return nil, cerr	279		return nil, cerr

@@ -455,7 +455,7 @@ func (x *TlsCertificate) GetPropertyCertificate() []byte {
455		func (x *TlsCertificate) SetPropertyCertificatePem(value string) {	455		func (x *TlsCertificate) SetPropertyCertificatePem(value string) {
456		var v gobject.Value	456		var v gobject.Value
457		v.Init(gobject.TypeStringVal)	457		v.Init(gobject.TypeStringVal)
458	-	v.SetString(value)	458	+	v.SetString(&value)
459		x.SetProperty("certificate-pem", &v)	459		x.SetProperty("certificate-pem", &v)
460		}	460		}
461			461

@@ -527,7 +527,7 @@ func (x *TlsCertificate) GetPropertyNotValidBefore() uintptr {
527		func (x *TlsCertificate) SetPropertyPassword(value string) {	527		func (x *TlsCertificate) SetPropertyPassword(value string) {
528		var v gobject.Value	528		var v gobject.Value
529		v.Init(gobject.TypeStringVal)	529		v.Init(gobject.TypeStringVal)
530	-	v.SetString(value)	530	+	v.SetString(&value)
531		x.SetProperty("password", &v)	531		x.SetProperty("password", &v)
532		}	532		}
533			533

@@ -540,7 +540,7 @@ func (x *TlsCertificate) SetPropertyPassword(value string) {
540		func (x *TlsCertificate) SetPropertyPkcs11Uri(value string) {	540		func (x *TlsCertificate) SetPropertyPkcs11Uri(value string) {
541		var v gobject.Value	541		var v gobject.Value
542		v.Init(gobject.TypeStringVal)	542		v.Init(gobject.TypeStringVal)
543	-	v.SetString(value)	543	+	v.SetString(&value)
544		x.SetProperty("pkcs11-uri", &v)	544		x.SetProperty("pkcs11-uri", &v)
545		}	545		}
546			546

@@ -642,7 +642,7 @@ func (x *TlsCertificate) GetPropertyPrivateKey() []byte {
642		func (x *TlsCertificate) SetPropertyPrivateKeyPem(value string) {	642		func (x *TlsCertificate) SetPropertyPrivateKeyPem(value string) {
643		var v gobject.Value	643		var v gobject.Value
644		v.Init(gobject.TypeStringVal)	644		v.Init(gobject.TypeStringVal)
645	-	v.SetString(value)	645	+	v.SetString(&value)
646		x.SetProperty("private-key-pem", &v)	646		x.SetProperty("private-key-pem", &v)
647		}	647		}
648			648

@@ -677,7 +677,7 @@ func (x *TlsCertificate) GetPropertyPrivateKeyPem() string {
677		func (x *TlsCertificate) SetPropertyPrivateKeyPkcs11Uri(value string) {	677		func (x *TlsCertificate) SetPropertyPrivateKeyPkcs11Uri(value string) {
678		var v gobject.Value	678		var v gobject.Value
679		v.Init(gobject.TypeStringVal)	679		v.Init(gobject.TypeStringVal)
680	-	v.SetString(value)	680	+	v.SetString(&value)
681		x.SetProperty("private-key-pkcs11-uri", &v)	681		x.SetProperty("private-key-pkcs11-uri", &v)
682		}	682		}
683			683

M v4/gio/gtlsconnection.go +16 -1


@@ -483,7 +483,22 @@ var xTlsConnectionHandshakeAsync func(uintptr, int, uintptr, uintptr, uintptr)
483		// g_tls_connection_handshake() for more information.	483		// g_tls_connection_handshake() for more information.
484		func (x TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	484		func (x TlsConnection) HandshakeAsync(IoPriorityVar int, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
485			485
486	-	xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	486	+	var CallbackVarRef uintptr
			487	+	if CallbackVar != nil {
			488	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			489	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			490	+	CallbackVarRef = cbRefPtr
			491	+	} else {
			492	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			493	+	cbFn := *CallbackVar
			494	+	cbFn(arg0, arg1, arg2)
			495	+	}
			496	+	CallbackVarRef = purego.NewCallback(fcb)
			497	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			498	+	}
			499	+	}
			500	+
			501	+	xTlsConnectionHandshakeAsync(x.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
487			502
488		}	503		}
489			504

M v4/gio/gtlsdatabase.go +64 -4


@@ -566,7 +566,22 @@ var xTlsDatabaseLookupCertificateForHandleAsync func(uintptr, string, uintptr, T
566		// g_tls_database_lookup_certificate_for_handle() for more information.	566		// g_tls_database_lookup_certificate_for_handle() for more information.
567		func (x TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	567		func (x TlsDatabase) LookupCertificateForHandleAsync(HandleVar string, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
568			568
569	-	xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	569	+	var CallbackVarRef uintptr
			570	+	if CallbackVar != nil {
			571	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			572	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			573	+	CallbackVarRef = cbRefPtr
			574	+	} else {
			575	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			576	+	cbFn := *CallbackVar
			577	+	cbFn(arg0, arg1, arg2)
			578	+	}
			579	+	CallbackVarRef = purego.NewCallback(fcb)
			580	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			581	+	}
			582	+	}
			583	+
			584	+	xTlsDatabaseLookupCertificateForHandleAsync(x.GoPointer(), HandleVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
570			585
571		}	586		}
572			587

@@ -641,7 +656,22 @@ var xTlsDatabaseLookupCertificateIssuerAsync func(uintptr, uintptr, uintptr, Tls
641		// g_tls_database_lookup_certificate_issuer() for more information.	656		// g_tls_database_lookup_certificate_issuer() for more information.
642		func (x TlsDatabase) LookupCertificateIssuerAsync(CertificateVar TlsCertificate, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	657		func (x TlsDatabase) LookupCertificateIssuerAsync(CertificateVar TlsCertificate, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
643			658
644	-	xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	659	+	var CallbackVarRef uintptr
			660	+	if CallbackVar != nil {
			661	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			662	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			663	+	CallbackVarRef = cbRefPtr
			664	+	} else {
			665	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			666	+	cbFn := *CallbackVar
			667	+	cbFn(arg0, arg1, arg2)
			668	+	}
			669	+	CallbackVarRef = purego.NewCallback(fcb)
			670	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			671	+	}
			672	+	}
			673	+
			674	+	xTlsDatabaseLookupCertificateIssuerAsync(x.GoPointer(), CertificateVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
645			675
646		}	676		}
647			677

@@ -694,7 +724,22 @@ var xTlsDatabaseLookupCertificatesIssuedByAsync func(uintptr, []byte, uintptr, T
694		// this time.	724		// this time.
695		func (x TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar []byte, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	725		func (x TlsDatabase) LookupCertificatesIssuedByAsync(IssuerRawDnVar []byte, InteractionVar TlsInteraction, FlagsVar TlsDatabaseLookupFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
696			726
697	-	xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	727	+	var CallbackVarRef uintptr
			728	+	if CallbackVar != nil {
			729	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			730	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			731	+	CallbackVarRef = cbRefPtr
			732	+	} else {
			733	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			734	+	cbFn := *CallbackVar
			735	+	cbFn(arg0, arg1, arg2)
			736	+	}
			737	+	CallbackVarRef = purego.NewCallback(fcb)
			738	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			739	+	}
			740	+	}
			741	+
			742	+	xTlsDatabaseLookupCertificatesIssuedByAsync(x.GoPointer(), IssuerRawDnVar, InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
698			743
699		}	744		}
700			745

@@ -793,7 +838,22 @@ var xTlsDatabaseVerifyChainAsync func(uintptr, uintptr, string, uintptr, uintptr
793		// g_tls_database_verify_chain() for more information.	838		// g_tls_database_verify_chain() for more information.
794		func (x TlsDatabase) VerifyChainAsync(ChainVar TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	839		func (x TlsDatabase) VerifyChainAsync(ChainVar TlsCertificate, PurposeVar string, IdentityVar SocketConnectable, InteractionVar TlsInteraction, FlagsVar TlsDatabaseVerifyFlags, CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
795			840
796	-	xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	841	+	var CallbackVarRef uintptr
			842	+	if CallbackVar != nil {
			843	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			844	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			845	+	CallbackVarRef = cbRefPtr
			846	+	} else {
			847	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			848	+	cbFn := *CallbackVar
			849	+	cbFn(arg0, arg1, arg2)
			850	+	}
			851	+	CallbackVarRef = purego.NewCallback(fcb)
			852	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			853	+	}
			854	+	}
			855	+
			856	+	xTlsDatabaseVerifyChainAsync(x.GoPointer(), ChainVar.GoPointer(), PurposeVar, IdentityVar.GoPointer(), InteractionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
797			857
798		}	858		}
799			859

M v4/gio/gtlsfiledatabase.go +1 -1


@@ -64,7 +64,7 @@ func (x *TlsFileDatabaseBase) SetPropertyAnchors(value string) {
64		obj.Ptr = x.GoPointer()	64		obj.Ptr = x.GoPointer()
65		var v gobject.Value	65		var v gobject.Value
66		v.Init(gobject.TypeStringVal)	66		v.Init(gobject.TypeStringVal)
67	-	v.SetString(value)	67	+	v.SetString(&value)
68		obj.SetProperty("anchors", &v)	68		obj.SetProperty("anchors", &v)
69		}	69		}
70			70

M v4/gio/gtlsinteraction.go +32 -2


@@ -321,7 +321,22 @@ var xTlsInteractionAskPasswordAsync func(uintptr, uintptr, uintptr, uintptr, uin
321		// Certain implementations may not support immediate cancellation.	321		// Certain implementations may not support immediate cancellation.
322		func (x TlsInteraction) AskPasswordAsync(PasswordVar TlsPassword, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	322		func (x TlsInteraction) AskPasswordAsync(PasswordVar TlsPassword, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
323			323
324	-	xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	324	+	var CallbackVarRef uintptr
			325	+	if CallbackVar != nil {
			326	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			327	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			328	+	CallbackVarRef = cbRefPtr
			329	+	} else {
			330	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			331	+	cbFn := *CallbackVar
			332	+	cbFn(arg0, arg1, arg2)
			333	+	}
			334	+	CallbackVarRef = purego.NewCallback(fcb)
			335	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			336	+	}
			337	+	}
			338	+
			339	+	xTlsInteractionAskPasswordAsync(x.GoPointer(), PasswordVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
325			340
326		}	341		}
327			342

@@ -453,7 +468,22 @@ var xTlsInteractionRequestCertificateAsync func(uintptr, uintptr, TlsCertificate
453		// request, which will usually abort the TLS connection.	468		// request, which will usually abort the TLS connection.
454		func (x TlsInteraction) RequestCertificateAsync(ConnectionVar TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {	469		func (x TlsInteraction) RequestCertificateAsync(ConnectionVar TlsConnection, FlagsVar TlsCertificateRequestFlags, CancellableVar Cancellable, CallbackVar AsyncReadyCallback, UserDataVar uintptr) {
455			470
456	-	xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	471	+	var CallbackVarRef uintptr
			472	+	if CallbackVar != nil {
			473	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			474	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			475	+	CallbackVarRef = cbRefPtr
			476	+	} else {
			477	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			478	+	cbFn := *CallbackVar
			479	+	cbFn(arg0, arg1, arg2)
			480	+	}
			481	+	CallbackVarRef = purego.NewCallback(fcb)
			482	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			483	+	}
			484	+	}
			485	+
			486	+	xTlsInteractionRequestCertificateAsync(x.GoPointer(), ConnectionVar.GoPointer(), FlagsVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
457			487
458		}	488		}
459			489

M v4/gio/gtlspassword.go +18 -3

 // considered part of the password in this case.)
 func (x *TlsPassword) SetValueFull(ValueVar []byte, LengthVar int, DestroyVar *glib.DestroyNotify) {
-	xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, glib.NewCallbackNullable(DestroyVar))
+	var DestroyVarRef uintptr
+	if DestroyVar != nil {
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+			DestroyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
+		}
+	}
+	xTlsPasswordSetValueFull(x.GoPointer(), ValueVar, LengthVar, DestroyVarRef)
 }
 func (x *TlsPassword) SetPropertyDescription(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("description", &v)
 }
 func (x *TlsPassword) SetPropertyWarning(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("warning", &v)
 }

M v4/gio/gunixconnection.go +32 -2


@@ -106,7 +106,22 @@ var xUnixConnectionReceiveCredentialsAsync func(uintptr, uintptr, uintptr, uintp
106		// g_unix_connection_receive_credentials_finish() to get the result of the operation.	106		// g_unix_connection_receive_credentials_finish() to get the result of the operation.
107		func (x UnixConnection) ReceiveCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	107		func (x UnixConnection) ReceiveCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
108			108
109	-	xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	109	+	var CallbackVarRef uintptr
			110	+	if CallbackVar != nil {
			111	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			112	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			113	+	CallbackVarRef = cbRefPtr
			114	+	} else {
			115	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			116	+	cbFn := *CallbackVar
			117	+	cbFn(arg0, arg1, arg2)
			118	+	}
			119	+	CallbackVarRef = purego.NewCallback(fcb)
			120	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			121	+	}
			122	+	}
			123	+
			124	+	xUnixConnectionReceiveCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
110			125
111		}	126		}
112			127

@@ -195,7 +210,22 @@ var xUnixConnectionSendCredentialsAsync func(uintptr, uintptr, uintptr, uintptr)
195		// g_unix_connection_send_credentials_finish() to get the result of the operation.	210		// g_unix_connection_send_credentials_finish() to get the result of the operation.
196		func (x UnixConnection) SendCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {	211		func (x UnixConnection) SendCredentialsAsync(CancellableVar Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
197			212
198	-	xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	213	+	var CallbackVarRef uintptr
			214	+	if CallbackVar != nil {
			215	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			216	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			217	+	CallbackVarRef = cbRefPtr
			218	+	} else {
			219	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			220	+	cbFn := *CallbackVar
			221	+	cbFn(arg0, arg1, arg2)
			222	+	}
			223	+	CallbackVarRef = purego.NewCallback(fcb)
			224	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			225	+	}
			226	+	}
			227	+
			228	+	xUnixConnectionSendCredentialsAsync(x.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
199			229
200		}	230		}
201			231

M v4/gio/gunixsocketaddress.go +1 -1


@@ -223,7 +223,7 @@ func (x *UnixSocketAddress) GetPropertyAbstract() bool {
223		func (x *UnixSocketAddress) SetPropertyPath(value string) {	223		func (x *UnixSocketAddress) SetPropertyPath(value string) {
224		var v gobject.Value	224		var v gobject.Value
225		v.Init(gobject.TypeStringVal)	225		v.Init(gobject.TypeStringVal)
226	-	v.SetString(value)	226	+	v.SetString(&value)
227		x.SetProperty("path", &v)	227		x.SetProperty("path", &v)
228		}	228		}
229			229

M v4/gio/gvfs.go +61 -1


@@ -614,7 +614,67 @@ var xVfsRegisterUriScheme func(uintptr, string, uintptr, uintptr, uintptr, uintp
614		// a custom URI scheme, use g_vfs_unregister_uri_scheme().	614		// a custom URI scheme, use g_vfs_unregister_uri_scheme().
615		func (x Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar glib.DestroyNotify, ParseNameFuncVar VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {	615		func (x Vfs) RegisterUriScheme(SchemeVar string, UriFuncVar VfsFileLookupFunc, UriDataVar uintptr, UriDestroyVar glib.DestroyNotify, ParseNameFuncVar VfsFileLookupFunc, ParseNameDataVar uintptr, ParseNameDestroyVar *glib.DestroyNotify) bool {
616			616
617	-	cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, glib.NewCallbackNullable(UriFuncVar), UriDataVar, glib.NewCallbackNullable(UriDestroyVar), glib.NewCallbackNullable(ParseNameFuncVar), ParseNameDataVar, glib.NewCallbackNullable(ParseNameDestroyVar))	617	+	var UriFuncVarRef uintptr
			618	+	if UriFuncVar != nil {
			619	+	UriFuncVarPtr := uintptr(unsafe.Pointer(UriFuncVar))
			620	+	if cbRefPtr, ok := glib.GetCallback(UriFuncVarPtr); ok {
			621	+	UriFuncVarRef = cbRefPtr
			622	+	} else {
			623	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) uintptr {
			624	+	cbFn := *UriFuncVar
			625	+	return cbFn(arg0, arg1, arg2)
			626	+	}
			627	+	UriFuncVarRef = purego.NewCallback(fcb)
			628	+	glib.SaveCallback(UriFuncVarPtr, UriFuncVarRef)
			629	+	}
			630	+	}
			631	+
			632	+	var UriDestroyVarRef uintptr
			633	+	if UriDestroyVar != nil {
			634	+	UriDestroyVarPtr := uintptr(unsafe.Pointer(UriDestroyVar))
			635	+	if cbRefPtr, ok := glib.GetCallback(UriDestroyVarPtr); ok {
			636	+	UriDestroyVarRef = cbRefPtr
			637	+	} else {
			638	+	fcb := func(arg0 uintptr) {
			639	+	cbFn := *UriDestroyVar
			640	+	cbFn(arg0)
			641	+	}
			642	+	UriDestroyVarRef = purego.NewCallback(fcb)
			643	+	glib.SaveCallback(UriDestroyVarPtr, UriDestroyVarRef)
			644	+	}
			645	+	}
			646	+
			647	+	var ParseNameFuncVarRef uintptr
			648	+	if ParseNameFuncVar != nil {
			649	+	ParseNameFuncVarPtr := uintptr(unsafe.Pointer(ParseNameFuncVar))
			650	+	if cbRefPtr, ok := glib.GetCallback(ParseNameFuncVarPtr); ok {
			651	+	ParseNameFuncVarRef = cbRefPtr
			652	+	} else {
			653	+	fcb := func(arg0 uintptr, arg1 string, arg2 uintptr) uintptr {
			654	+	cbFn := *ParseNameFuncVar
			655	+	return cbFn(arg0, arg1, arg2)
			656	+	}
			657	+	ParseNameFuncVarRef = purego.NewCallback(fcb)
			658	+	glib.SaveCallback(ParseNameFuncVarPtr, ParseNameFuncVarRef)
			659	+	}
			660	+	}
			661	+
			662	+	var ParseNameDestroyVarRef uintptr
			663	+	if ParseNameDestroyVar != nil {
			664	+	ParseNameDestroyVarPtr := uintptr(unsafe.Pointer(ParseNameDestroyVar))
			665	+	if cbRefPtr, ok := glib.GetCallback(ParseNameDestroyVarPtr); ok {
			666	+	ParseNameDestroyVarRef = cbRefPtr
			667	+	} else {
			668	+	fcb := func(arg0 uintptr) {
			669	+	cbFn := *ParseNameDestroyVar
			670	+	cbFn(arg0)
			671	+	}
			672	+	ParseNameDestroyVarRef = purego.NewCallback(fcb)
			673	+	glib.SaveCallback(ParseNameDestroyVarPtr, ParseNameDestroyVarRef)
			674	+	}
			675	+	}
			676	+
			677	+	cret := xVfsRegisterUriScheme(x.GoPointer(), SchemeVar, UriFuncVarRef, UriDataVar, UriDestroyVarRef, ParseNameFuncVarRef, ParseNameDataVar, ParseNameDestroyVarRef)
618		return cret	678		return cret
619		}	679		}
620			680

M v4/glib/garray.go +158 -8


@@ -147,7 +147,22 @@ var xNewBytesWithFreeFunc func([]byte, uint, uintptr, uintptr) *Bytes
147		// @data may be `NULL` if @size is 0.	147		// @data may be `NULL` if @size is 0.
148		func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) Bytes {	148		func NewBytesWithFreeFunc(DataVar []byte, SizeVar uint, FreeFuncVar DestroyNotify, UserDataVar uintptr) Bytes {
149			149
150	-	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, NewCallback(FreeFuncVar), UserDataVar)	150	+	var FreeFuncVarRef uintptr
			151	+	if FreeFuncVar != nil {
			152	+	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
			153	+	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
			154	+	FreeFuncVarRef = cbRefPtr
			155	+	} else {
			156	+	fcb := func(arg0 uintptr) {
			157	+	cbFn := *FreeFuncVar
			158	+	cbFn(arg0)
			159	+	}
			160	+	FreeFuncVarRef = purego.NewCallback(fcb)
			161	+	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
			162	+	}
			163	+	}
			164	+
			165	+	cret := xNewBytesWithFreeFunc(DataVar, SizeVar, FreeFuncVarRef, UserDataVar)
151		return cret	166		return cret
152		}	167		}
153			168

@@ -553,7 +568,22 @@ var xByteArraySort func([]byte, uintptr)
553		// their addresses.	568		// their addresses.
554		func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {	569		func ByteArraySort(ArrayVar []byte, CompareFuncVar *CompareFunc) {
555			570
556	-	xByteArraySort(ArrayVar, NewCallback(CompareFuncVar))	571	+	var CompareFuncVarRef uintptr
			572	+	if CompareFuncVar != nil {
			573	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			574	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
			575	+	CompareFuncVarRef = cbRefPtr
			576	+	} else {
			577	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			578	+	cbFn := *CompareFuncVar
			579	+	return cbFn(arg0, arg1)
			580	+	}
			581	+	CompareFuncVarRef = purego.NewCallback(fcb)
			582	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			583	+	}
			584	+	}
			585	+
			586	+	xByteArraySort(ArrayVar, CompareFuncVarRef)
557			587
558		}	588		}
559			589

@@ -563,7 +593,22 @@ var xByteArraySortWithData func([]byte, uintptr, uintptr)
563		// user data argument.	593		// user data argument.
564		func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {	594		func ByteArraySortWithData(ArrayVar []byte, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
565			595
566	-	xByteArraySortWithData(ArrayVar, NewCallback(CompareFuncVar), UserDataVar)	596	+	var CompareFuncVarRef uintptr
			597	+	if CompareFuncVar != nil {
			598	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			599	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
			600	+	CompareFuncVarRef = cbRefPtr
			601	+	} else {
			602	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			603	+	cbFn := *CompareFuncVar
			604	+	return cbFn(arg0, arg1, arg2)
			605	+	}
			606	+	CompareFuncVarRef = purego.NewCallback(fcb)
			607	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			608	+	}
			609	+	}
			610	+
			611	+	xByteArraySortWithData(ArrayVar, CompareFuncVarRef, UserDataVar)
567			612
568		}	613		}
569			614

@@ -619,7 +664,22 @@ var xPtrArrayFindWithEqualFunc func([]uintptr, uintptr, uintptr, *uint) bool
619		// equality is used.	664		// equality is used.
620		func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar EqualFunc, IndexVar uint) bool {	665		func PtrArrayFindWithEqualFunc(HaystackVar []uintptr, NeedleVar uintptr, EqualFuncVar EqualFunc, IndexVar uint) bool {
621			666
622	-	cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, NewCallbackNullable(EqualFuncVar), IndexVar)	667	+	var EqualFuncVarRef uintptr
			668	+	if EqualFuncVar != nil {
			669	+	EqualFuncVarPtr := uintptr(unsafe.Pointer(EqualFuncVar))
			670	+	if cbRefPtr, ok := GetCallback(EqualFuncVarPtr); ok {
			671	+	EqualFuncVarRef = cbRefPtr
			672	+	} else {
			673	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			674	+	cbFn := *EqualFuncVar
			675	+	return cbFn(arg0, arg1)
			676	+	}
			677	+	EqualFuncVarRef = purego.NewCallback(fcb)
			678	+	SaveCallback(EqualFuncVarPtr, EqualFuncVarRef)
			679	+	}
			680	+	}
			681	+
			682	+	cret := xPtrArrayFindWithEqualFunc(HaystackVar, NeedleVar, EqualFuncVarRef, IndexVar)
623		return cret	683		return cret
624		}	684		}
625			685

@@ -644,7 +704,37 @@ var xPtrArrayNewFromArray func([]uintptr, uint, uintptr, uintptr, uintptr) uintp
644		// than `gsize`.	704		// than `gsize`.
645		func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar DestroyNotify) uintptr {	705		func PtrArrayNewFromArray(DataVar []uintptr, LenVar uint, CopyFuncVar CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar DestroyNotify) uintptr {
646			706
647	-	cret := xPtrArrayNewFromArray(DataVar, LenVar, NewCallbackNullable(CopyFuncVar), CopyFuncUserDataVar, NewCallbackNullable(ElementFreeFuncVar))	707	+	var CopyFuncVarRef uintptr
			708	+	if CopyFuncVar != nil {
			709	+	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
			710	+	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
			711	+	CopyFuncVarRef = cbRefPtr
			712	+	} else {
			713	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			714	+	cbFn := *CopyFuncVar
			715	+	return cbFn(arg0, arg1)
			716	+	}
			717	+	CopyFuncVarRef = purego.NewCallback(fcb)
			718	+	SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
			719	+	}
			720	+	}
			721	+
			722	+	var ElementFreeFuncVarRef uintptr
			723	+	if ElementFreeFuncVar != nil {
			724	+	ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
			725	+	if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
			726	+	ElementFreeFuncVarRef = cbRefPtr
			727	+	} else {
			728	+	fcb := func(arg0 uintptr) {
			729	+	cbFn := *ElementFreeFuncVar
			730	+	cbFn(arg0)
			731	+	}
			732	+	ElementFreeFuncVarRef = purego.NewCallback(fcb)
			733	+	SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
			734	+	}
			735	+	}
			736	+
			737	+	cret := xPtrArrayNewFromArray(DataVar, LenVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
648		return cret	738		return cret
649		}	739		}
650			740

@@ -665,7 +755,37 @@ var xPtrArrayNewFromNullTerminatedArray func([]uintptr, uintptr, uintptr, uintpt
665		// shorter than `gsize`.	755		// shorter than `gsize`.
666		func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar DestroyNotify) uintptr {	756		func PtrArrayNewFromNullTerminatedArray(DataVar []uintptr, CopyFuncVar CopyFunc, CopyFuncUserDataVar uintptr, ElementFreeFuncVar DestroyNotify) uintptr {
667			757
668	-	cret := xPtrArrayNewFromNullTerminatedArray(DataVar, NewCallbackNullable(CopyFuncVar), CopyFuncUserDataVar, NewCallbackNullable(ElementFreeFuncVar))	758	+	var CopyFuncVarRef uintptr
			759	+	if CopyFuncVar != nil {
			760	+	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
			761	+	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
			762	+	CopyFuncVarRef = cbRefPtr
			763	+	} else {
			764	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			765	+	cbFn := *CopyFuncVar
			766	+	return cbFn(arg0, arg1)
			767	+	}
			768	+	CopyFuncVarRef = purego.NewCallback(fcb)
			769	+	SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
			770	+	}
			771	+	}
			772	+
			773	+	var ElementFreeFuncVarRef uintptr
			774	+	if ElementFreeFuncVar != nil {
			775	+	ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
			776	+	if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
			777	+	ElementFreeFuncVarRef = cbRefPtr
			778	+	} else {
			779	+	fcb := func(arg0 uintptr) {
			780	+	cbFn := *ElementFreeFuncVar
			781	+	cbFn(arg0)
			782	+	}
			783	+	ElementFreeFuncVarRef = purego.NewCallback(fcb)
			784	+	SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
			785	+	}
			786	+	}
			787	+
			788	+	cret := xPtrArrayNewFromNullTerminatedArray(DataVar, CopyFuncVarRef, CopyFuncUserDataVar, ElementFreeFuncVarRef)
669		return cret	789		return cret
670		}	790		}
671			791

@@ -689,7 +809,22 @@ var xPtrArrayNewTake func([]uintptr, uint, uintptr) uintptr
689		// than `gsize`.	809		// than `gsize`.
690		func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *DestroyNotify) uintptr {	810		func PtrArrayNewTake(DataVar []uintptr, LenVar uint, ElementFreeFuncVar *DestroyNotify) uintptr {
691			811
692	-	cret := xPtrArrayNewTake(DataVar, LenVar, NewCallbackNullable(ElementFreeFuncVar))	812	+	var ElementFreeFuncVarRef uintptr
			813	+	if ElementFreeFuncVar != nil {
			814	+	ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
			815	+	if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
			816	+	ElementFreeFuncVarRef = cbRefPtr
			817	+	} else {
			818	+	fcb := func(arg0 uintptr) {
			819	+	cbFn := *ElementFreeFuncVar
			820	+	cbFn(arg0)
			821	+	}
			822	+	ElementFreeFuncVarRef = purego.NewCallback(fcb)
			823	+	SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
			824	+	}
			825	+	}
			826	+
			827	+	cret := xPtrArrayNewTake(DataVar, LenVar, ElementFreeFuncVarRef)
693		return cret	828		return cret
694		}	829		}
695			830

@@ -716,7 +851,22 @@ var xPtrArrayNewTakeNullTerminated func([]uintptr, uintptr) uintptr
716		// in `guint`, which may be shorter than `gsize`.	851		// in `guint`, which may be shorter than `gsize`.
717		func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {	852		func PtrArrayNewTakeNullTerminated(DataVar []uintptr, ElementFreeFuncVar *DestroyNotify) uintptr {
718			853
719	-	cret := xPtrArrayNewTakeNullTerminated(DataVar, NewCallbackNullable(ElementFreeFuncVar))	854	+	var ElementFreeFuncVarRef uintptr
			855	+	if ElementFreeFuncVar != nil {
			856	+	ElementFreeFuncVarPtr := uintptr(unsafe.Pointer(ElementFreeFuncVar))
			857	+	if cbRefPtr, ok := GetCallback(ElementFreeFuncVarPtr); ok {
			858	+	ElementFreeFuncVarRef = cbRefPtr
			859	+	} else {
			860	+	fcb := func(arg0 uintptr) {
			861	+	cbFn := *ElementFreeFuncVar
			862	+	cbFn(arg0)
			863	+	}
			864	+	ElementFreeFuncVarRef = purego.NewCallback(fcb)
			865	+	SaveCallback(ElementFreeFuncVarPtr, ElementFreeFuncVarRef)
			866	+	}
			867	+	}
			868	+
			869	+	cret := xPtrArrayNewTakeNullTerminated(DataVar, ElementFreeFuncVarRef)
720		return cret	870		return cret
721		}	871		}
722			872

M v4/glib/gasyncqueue.go +80 -5


@@ -144,7 +144,22 @@ var xAsyncQueuePushSorted func(uintptr, uintptr, uintptr, uintptr)
144		// For an example of @func see g_async_queue_sort().	144		// For an example of @func see g_async_queue_sort().
145		func (x AsyncQueue) PushSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	145		func (x AsyncQueue) PushSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
146			146
147	-	xAsyncQueuePushSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)	147	+	var FuncVarRef uintptr
			148	+	if FuncVar != nil {
			149	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			150	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			151	+	FuncVarRef = cbRefPtr
			152	+	} else {
			153	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			154	+	cbFn := *FuncVar
			155	+	return cbFn(arg0, arg1, arg2)
			156	+	}
			157	+	FuncVarRef = purego.NewCallback(fcb)
			158	+	SaveCallback(FuncVarPtr, FuncVarRef)
			159	+	}
			160	+	}
			161	+
			162	+	xAsyncQueuePushSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
148			163
149		}	164		}
150			165

@@ -167,7 +182,22 @@ var xAsyncQueuePushSortedUnlocked func(uintptr, uintptr, uintptr, uintptr)
167		// For an example of @func see g_async_queue_sort().	182		// For an example of @func see g_async_queue_sort().
168		func (x AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	183		func (x AsyncQueue) PushSortedUnlocked(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
169			184
170	-	xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)	185	+	var FuncVarRef uintptr
			186	+	if FuncVar != nil {
			187	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			188	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			189	+	FuncVarRef = cbRefPtr
			190	+	} else {
			191	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			192	+	cbFn := *FuncVar
			193	+	return cbFn(arg0, arg1, arg2)
			194	+	}
			195	+	FuncVarRef = purego.NewCallback(fcb)
			196	+	SaveCallback(FuncVarPtr, FuncVarRef)
			197	+	}
			198	+	}
			199	+
			200	+	xAsyncQueuePushSortedUnlocked(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
171			201
172		}	202		}
173			203

@@ -251,7 +281,22 @@ var xAsyncQueueSort func(uintptr, uintptr, uintptr)
251		// ]\|	281		// ]\|
252		func (x AsyncQueue) Sort(FuncVar CompareDataFunc, UserDataVar uintptr) {	282		func (x AsyncQueue) Sort(FuncVar CompareDataFunc, UserDataVar uintptr) {
253			283
254	-	xAsyncQueueSort(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	284	+	var FuncVarRef uintptr
			285	+	if FuncVar != nil {
			286	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			287	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			288	+	FuncVarRef = cbRefPtr
			289	+	} else {
			290	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			291	+	cbFn := *FuncVar
			292	+	return cbFn(arg0, arg1, arg2)
			293	+	}
			294	+	FuncVarRef = purego.NewCallback(fcb)
			295	+	SaveCallback(FuncVarPtr, FuncVarRef)
			296	+	}
			297	+	}
			298	+
			299	+	xAsyncQueueSort(x.GoPointer(), FuncVarRef, UserDataVar)
255			300
256		}	301		}
257			302

@@ -268,7 +313,22 @@ var xAsyncQueueSortUnlocked func(uintptr, uintptr, uintptr)
268		// This function must be called while holding the @queue's lock.	313		// This function must be called while holding the @queue's lock.
269		func (x AsyncQueue) SortUnlocked(FuncVar CompareDataFunc, UserDataVar uintptr) {	314		func (x AsyncQueue) SortUnlocked(FuncVar CompareDataFunc, UserDataVar uintptr) {
270			315
271	-	xAsyncQueueSortUnlocked(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	316	+	var FuncVarRef uintptr
			317	+	if FuncVar != nil {
			318	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			319	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			320	+	FuncVarRef = cbRefPtr
			321	+	} else {
			322	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			323	+	cbFn := *FuncVar
			324	+	return cbFn(arg0, arg1, arg2)
			325	+	}
			326	+	FuncVarRef = purego.NewCallback(fcb)
			327	+	SaveCallback(FuncVarPtr, FuncVarRef)
			328	+	}
			329	+	}
			330	+
			331	+	xAsyncQueueSortUnlocked(x.GoPointer(), FuncVarRef, UserDataVar)
272			332
273		}	333		}
274			334

@@ -407,7 +467,22 @@ var xAsyncQueueNewFull func(uintptr) *AsyncQueue
407		// the queue is destroyed after the final unref.	467		// the queue is destroyed after the final unref.
408		func AsyncQueueNewFull(ItemFreeFuncVar DestroyNotify) AsyncQueue {	468		func AsyncQueueNewFull(ItemFreeFuncVar DestroyNotify) AsyncQueue {
409			469
410	-	cret := xAsyncQueueNewFull(NewCallbackNullable(ItemFreeFuncVar))	470	+	var ItemFreeFuncVarRef uintptr
			471	+	if ItemFreeFuncVar != nil {
			472	+	ItemFreeFuncVarPtr := uintptr(unsafe.Pointer(ItemFreeFuncVar))
			473	+	if cbRefPtr, ok := GetCallback(ItemFreeFuncVarPtr); ok {
			474	+	ItemFreeFuncVarRef = cbRefPtr
			475	+	} else {
			476	+	fcb := func(arg0 uintptr) {
			477	+	cbFn := *ItemFreeFuncVar
			478	+	cbFn(arg0)
			479	+	}
			480	+	ItemFreeFuncVarRef = purego.NewCallback(fcb)
			481	+	SaveCallback(ItemFreeFuncVarPtr, ItemFreeFuncVarRef)
			482	+	}
			483	+	}
			484	+
			485	+	cret := xAsyncQueueNewFull(ItemFreeFuncVarRef)
411		return cret	486		return cret
412		}	487		}
413			488

M v4/glib/gbacktrace.go +3 -3


@@ -64,7 +64,7 @@ func OnErrorQuery(PrgNameVar string) {
64			64
65		}	65		}
66			66
67	-	var xOnErrorStackTrace func(string)	67	+	var xOnErrorStackTrace func(uintptr)
68			68
69		// Invokes gdb, which attaches to the current process and shows a	69		// Invokes gdb, which attaches to the current process and shows a
70		// stack trace. Called by g_on_error_query() when the "[S]tack trace"	70		// stack trace. Called by g_on_error_query() when the "[S]tack trace"

@@ -79,9 +79,9 @@ var xOnErrorStackTrace func(string)
79		// exception, which will crash the program. If the `G_DEBUGGER` environment	79		// exception, which will crash the program. If the `G_DEBUGGER` environment
80		// variable is set, a debugger will be invoked to attach and	80		// variable is set, a debugger will be invoked to attach and
81		// handle that exception (see [Running GLib Applications](running.html)).	81		// handle that exception (see [Running GLib Applications](running.html)).
82	-	func OnErrorStackTrace(PrgNameVar string) {	82	+	func OnErrorStackTrace(PrgNameVar *string) {
83			83
84	-	xOnErrorStackTrace(PrgNameVar)	84	+	xOnErrorStackTrace(core.NullableStringToPtr(PrgNameVar))
85			85
86		}	86		}
87			87

M v4/glib/gbookmarkfile.go +18 -18


@@ -74,7 +74,7 @@ func NewBookmarkFile() *BookmarkFile {
74		return cret	74		return cret
75		}	75		}
76			76
77	-	var xBookmarkFileAddApplication func(uintptr, string, string, string)	77	+	var xBookmarkFileAddApplication func(uintptr, string, uintptr, uintptr)
78			78
79		// Adds the application with @name and @exec to the list of	79		// Adds the application with @name and @exec to the list of
80		// applications that have registered a bookmark for @uri into	80		// applications that have registered a bookmark for @uri into

@@ -98,9 +98,9 @@ var xBookmarkFileAddApplication func(uintptr, string, string, string)
98		// @uri inside @bookmark.	98		// @uri inside @bookmark.
99		//	99		//
100		// If no bookmark for @uri is found, one is created.	100		// If no bookmark for @uri is found, one is created.
101	-	func (x *BookmarkFile) AddApplication(UriVar string, NameVar string, ExecVar string) {	101	+	func (x BookmarkFile) AddApplication(UriVar string, NameVar string, ExecVar *string) {
102			102
103	-	xBookmarkFileAddApplication(x.GoPointer(), UriVar, NameVar, ExecVar)	103	+	xBookmarkFileAddApplication(x.GoPointer(), UriVar, core.NullableStringToPtr(NameVar), core.NullableStringToPtr(ExecVar))
104			104
105		}	105		}
106			106

@@ -373,7 +373,7 @@ func (x *BookmarkFile) GetSize() int {
373		return cret	373		return cret
374		}	374		}
375			375
376	-	var xBookmarkFileGetTitle func(uintptr, string, **Error) string	376	+	var xBookmarkFileGetTitle func(uintptr, uintptr, **Error) string
377			377
378		// Returns the title of the bookmark for @uri.	378		// Returns the title of the bookmark for @uri.
379		//	379		//

@@ -381,10 +381,10 @@ var xBookmarkFileGetTitle func(uintptr, string, **Error) string
381		//	381		//
382		// In the event the URI cannot be found, %NULL is returned and	382		// In the event the URI cannot be found, %NULL is returned and
383		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.	383		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
384	-	func (x *BookmarkFile) GetTitle(UriVar string) (string, error) {	384	+	func (x BookmarkFile) GetTitle(UriVar string) (string, error) {
385		var cerr *Error	385		var cerr *Error
386			386
387	-	cret := xBookmarkFileGetTitle(x.GoPointer(), UriVar, &cerr)	387	+	cret := xBookmarkFileGetTitle(x.GoPointer(), core.NullableStringToPtr(UriVar), &cerr)
388		if cerr == nil {	388		if cerr == nil {
389		return cret, nil	389		return cret, nil
390		}	390		}

@@ -532,7 +532,7 @@ func (x *BookmarkFile) LoadFromFile(FilenameVar string) (bool, error) {
532			532
533		}	533		}
534			534
535	-	var xBookmarkFileMoveItem func(uintptr, string, string, **Error) bool	535	+	var xBookmarkFileMoveItem func(uintptr, string, uintptr, **Error) bool
536			536
537		// Changes the URI of a bookmark item from @old_uri to @new_uri. Any	537		// Changes the URI of a bookmark item from @old_uri to @new_uri. Any
538		// existing bookmark for @new_uri will be overwritten. If @new_uri is	538		// existing bookmark for @new_uri will be overwritten. If @new_uri is

@@ -540,10 +540,10 @@ var xBookmarkFileMoveItem func(uintptr, string, string, **Error) bool
540		//	540		//
541		// In the event the URI cannot be found, %FALSE is returned and	541		// In the event the URI cannot be found, %FALSE is returned and
542		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.	542		// @error is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
543	-	func (x *BookmarkFile) MoveItem(OldUriVar string, NewUriVar string) (bool, error) {	543	+	func (x BookmarkFile) MoveItem(OldUriVar string, NewUriVar string) (bool, error) {
544		var cerr *Error	544		var cerr *Error
545			545
546	-	cret := xBookmarkFileMoveItem(x.GoPointer(), OldUriVar, NewUriVar, &cerr)	546	+	cret := xBookmarkFileMoveItem(x.GoPointer(), OldUriVar, core.NullableStringToPtr(NewUriVar), &cerr)
547		if cerr == nil {	547		if cerr == nil {
548		return cret, nil	548		return cret, nil
549		}	549		}

@@ -709,16 +709,16 @@ func (x *BookmarkFile) SetApplicationInfo(UriVar string, NameVar string, ExecVar
709			709
710		}	710		}
711			711
712	-	var xBookmarkFileSetDescription func(uintptr, string, string)	712	+	var xBookmarkFileSetDescription func(uintptr, uintptr, string)
713			713
714		// Sets @description as the description of the bookmark for @uri.	714		// Sets @description as the description of the bookmark for @uri.
715		//	715		//
716		// If @uri is %NULL, the description of @bookmark is set.	716		// If @uri is %NULL, the description of @bookmark is set.
717		//	717		//
718		// If a bookmark for @uri cannot be found then it is created.	718		// If a bookmark for @uri cannot be found then it is created.
719	-	func (x *BookmarkFile) SetDescription(UriVar string, DescriptionVar string) {	719	+	func (x BookmarkFile) SetDescription(UriVar string, DescriptionVar string) {
720			720
721	-	xBookmarkFileSetDescription(x.GoPointer(), UriVar, DescriptionVar)	721	+	xBookmarkFileSetDescription(x.GoPointer(), core.NullableStringToPtr(UriVar), DescriptionVar)
722			722
723		}	723		}
724			724

@@ -734,16 +734,16 @@ func (x *BookmarkFile) SetGroups(UriVar string, GroupsVar []string, LengthVar ui
734			734
735		}	735		}
736			736
737	-	var xBookmarkFileSetIcon func(uintptr, string, string, string)	737	+	var xBookmarkFileSetIcon func(uintptr, string, uintptr, string)
738			738
739		// Sets the icon for the bookmark for @uri. If @href is %NULL, unsets	739		// Sets the icon for the bookmark for @uri. If @href is %NULL, unsets
740		// the currently set icon. @href can either be a full URL for the icon	740		// the currently set icon. @href can either be a full URL for the icon
741		// file or the icon name following the Icon Naming specification.	741		// file or the icon name following the Icon Naming specification.
742		//	742		//
743		// If no bookmark for @uri is found one is created.	743		// If no bookmark for @uri is found one is created.
744	-	func (x *BookmarkFile) SetIcon(UriVar string, HrefVar string, MimeTypeVar string) {	744	+	func (x BookmarkFile) SetIcon(UriVar string, HrefVar string, MimeTypeVar string) {
745			745
746	-	xBookmarkFileSetIcon(x.GoPointer(), UriVar, HrefVar, MimeTypeVar)	746	+	xBookmarkFileSetIcon(x.GoPointer(), UriVar, core.NullableStringToPtr(HrefVar), MimeTypeVar)
747			747
748		}	748		}
749			749

@@ -801,7 +801,7 @@ func (x BookmarkFile) SetModifiedDateTime(UriVar string, ModifiedVar DateTime)
801			801
802		}	802		}
803			803
804	-	var xBookmarkFileSetTitle func(uintptr, string, string)	804	+	var xBookmarkFileSetTitle func(uintptr, uintptr, string)
805			805
806		// Sets @title as the title of the bookmark for @uri inside the	806		// Sets @title as the title of the bookmark for @uri inside the
807		// bookmark file @bookmark.	807		// bookmark file @bookmark.

@@ -809,9 +809,9 @@ var xBookmarkFileSetTitle func(uintptr, string, string)
809		// If @uri is %NULL, the title of @bookmark is set.	809		// If @uri is %NULL, the title of @bookmark is set.
810		//	810		//
811		// If a bookmark for @uri cannot be found then it is created.	811		// If a bookmark for @uri cannot be found then it is created.
812	-	func (x *BookmarkFile) SetTitle(UriVar string, TitleVar string) {	812	+	func (x BookmarkFile) SetTitle(UriVar string, TitleVar string) {
813			813
814	-	xBookmarkFileSetTitle(x.GoPointer(), UriVar, TitleVar)	814	+	xBookmarkFileSetTitle(x.GoPointer(), core.NullableStringToPtr(UriVar), TitleVar)
815			815
816		}	816		}
817			817

M v4/glib/gcache.go +32 -2


@@ -80,7 +80,22 @@ var xCacheKeyForeach func(uintptr, uintptr, uintptr)
80		// pairs to its callback function !	80		// pairs to its callback function !
81		func (x Cache) KeyForeach(FuncVar HFunc, UserDataVar uintptr) {	81		func (x Cache) KeyForeach(FuncVar HFunc, UserDataVar uintptr) {
82			82
83	-	xCacheKeyForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	83	+	var FuncVarRef uintptr
			84	+	if FuncVar != nil {
			85	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			86	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			87	+	FuncVarRef = cbRefPtr
			88	+	} else {
			89	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			90	+	cbFn := *FuncVar
			91	+	cbFn(arg0, arg1, arg2)
			92	+	}
			93	+	FuncVarRef = purego.NewCallback(fcb)
			94	+	SaveCallback(FuncVarPtr, FuncVarRef)
			95	+	}
			96	+	}
			97	+
			98	+	xCacheKeyForeach(x.GoPointer(), FuncVarRef, UserDataVar)
84			99
85		}	100		}
86			101

@@ -100,7 +115,22 @@ var xCacheValueForeach func(uintptr, uintptr, uintptr)
100		// Calls the given function for each of the values in the #GCache.	115		// Calls the given function for each of the values in the #GCache.
101		func (x Cache) ValueForeach(FuncVar HFunc, UserDataVar uintptr) {	116		func (x Cache) ValueForeach(FuncVar HFunc, UserDataVar uintptr) {
102			117
103	-	xCacheValueForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	118	+	var FuncVarRef uintptr
			119	+	if FuncVar != nil {
			120	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			121	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			122	+	FuncVarRef = cbRefPtr
			123	+	} else {
			124	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			125	+	cbFn := *FuncVar
			126	+	cbFn(arg0, arg1, arg2)
			127	+	}
			128	+	FuncVarRef = purego.NewCallback(fcb)
			129	+	SaveCallback(FuncVarPtr, FuncVarRef)
			130	+	}
			131	+	}
			132	+
			133	+	xCacheValueForeach(x.GoPointer(), FuncVarRef, UserDataVar)
104			134
105		}	135		}
106			136

M v4/glib/gcompletion.go +16 -1


@@ -131,7 +131,22 @@ var xCompletionSetCompare func(uintptr, uintptr)
131		// comparison function is strncmp().	131		// comparison function is strncmp().
132		func (x Completion) SetCompare(StrncmpFuncVar CompletionStrncmpFunc) {	132		func (x Completion) SetCompare(StrncmpFuncVar CompletionStrncmpFunc) {
133			133
134	-	xCompletionSetCompare(x.GoPointer(), NewCallback(StrncmpFuncVar))	134	+	var StrncmpFuncVarRef uintptr
			135	+	if StrncmpFuncVar != nil {
			136	+	StrncmpFuncVarPtr := uintptr(unsafe.Pointer(StrncmpFuncVar))
			137	+	if cbRefPtr, ok := GetCallback(StrncmpFuncVarPtr); ok {
			138	+	StrncmpFuncVarRef = cbRefPtr
			139	+	} else {
			140	+	fcb := func(arg0 string, arg1 string, arg2 uint) int {
			141	+	cbFn := *StrncmpFuncVar
			142	+	return cbFn(arg0, arg1, arg2)
			143	+	}
			144	+	StrncmpFuncVarRef = purego.NewCallback(fcb)
			145	+	SaveCallback(StrncmpFuncVarPtr, StrncmpFuncVarRef)
			146	+	}
			147	+	}
			148	+
			149	+	xCompletionSetCompare(x.GoPointer(), StrncmpFuncVarRef)
135			150
136		}	151		}
137			152

M v4/glib/gconvert.go +3 -3


@@ -266,14 +266,14 @@ func FilenameFromUtf8(Utf8stringVar string, LenVar int, BytesReadVar *uint, Byte
266			266
267		}	267		}
268			268
269	-	var xFilenameToUri func(string, string, **Error) string	269	+	var xFilenameToUri func(string, uintptr, **Error) string
270			270
271		// Converts an absolute filename to an escaped ASCII-encoded URI, with the path	271		// Converts an absolute filename to an escaped ASCII-encoded URI, with the path
272		// component following Section 3.3. of RFC 2396.	272		// component following Section 3.3. of RFC 2396.
273	-	func FilenameToUri(FilenameVar string, HostnameVar string) (string, error) {	273	+	func FilenameToUri(FilenameVar string, HostnameVar *string) (string, error) {
274		var cerr *Error	274		var cerr *Error
275			275
276	-	cret := xFilenameToUri(FilenameVar, HostnameVar, &cerr)	276	+	cret := xFilenameToUri(FilenameVar, core.NullableStringToPtr(HostnameVar), &cerr)
277		if cerr == nil {	277		if cerr == nil {
278		return cret, nil	278		return cret, nil
279		}	279		}

M v4/glib/gdataset.go +96 -6


@@ -63,7 +63,22 @@ var xDatalistForeach func(**Data, uintptr, uintptr)
63		// than skipping over elements that are removed.	63		// than skipping over elements that are removed.
64		func DatalistForeach(DatalistVar *Data, FuncVar DataForeachFunc, UserDataVar uintptr) {	64		func DatalistForeach(DatalistVar *Data, FuncVar DataForeachFunc, UserDataVar uintptr) {
65			65
66	-	xDatalistForeach(DatalistVar, NewCallback(FuncVar), UserDataVar)	66	+	var FuncVarRef uintptr
			67	+	if FuncVar != nil {
			68	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			69	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			70	+	FuncVarRef = cbRefPtr
			71	+	} else {
			72	+	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
			73	+	cbFn := *FuncVar
			74	+	cbFn(arg0, arg1, arg2)
			75	+	}
			76	+	FuncVarRef = purego.NewCallback(fcb)
			77	+	SaveCallback(FuncVarPtr, FuncVarRef)
			78	+	}
			79	+	}
			80	+
			81	+	xDatalistForeach(DatalistVar, FuncVarRef, UserDataVar)
67			82
68		}	83		}
69			84

@@ -104,7 +119,22 @@ var xDatalistIdDupData func(**Data, Quark, uintptr, uintptr) uintptr
104		// threads are using the same datalist and the same key.	119		// threads are using the same datalist and the same key.
105		func DatalistIdDupData(DatalistVar *Data, KeyIdVar Quark, DupFuncVar DuplicateFunc, UserDataVar uintptr) uintptr {	120		func DatalistIdDupData(DatalistVar *Data, KeyIdVar Quark, DupFuncVar DuplicateFunc, UserDataVar uintptr) uintptr {
106			121
107	-	cret := xDatalistIdDupData(DatalistVar, KeyIdVar, NewCallbackNullable(DupFuncVar), UserDataVar)	122	+	var DupFuncVarRef uintptr
			123	+	if DupFuncVar != nil {
			124	+	DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
			125	+	if cbRefPtr, ok := GetCallback(DupFuncVarPtr); ok {
			126	+	DupFuncVarRef = cbRefPtr
			127	+	} else {
			128	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			129	+	cbFn := *DupFuncVar
			130	+	return cbFn(arg0, arg1)
			131	+	}
			132	+	DupFuncVarRef = purego.NewCallback(fcb)
			133	+	SaveCallback(DupFuncVarPtr, DupFuncVarRef)
			134	+	}
			135	+	}
			136	+
			137	+	cret := xDatalistIdDupData(DatalistVar, KeyIdVar, DupFuncVarRef, UserDataVar)
108		return cret	138		return cret
109		}	139		}
110			140

@@ -159,7 +189,22 @@ var xDatalistIdReplaceData func(*Data, Quark, uintptr, uintptr, uintptr, Destr
159		// should not destroy the object in the normal way.	189		// should not destroy the object in the normal way.
160		func DatalistIdReplaceData(DatalistVar *Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar *DestroyNotify) bool {	190		func DatalistIdReplaceData(DatalistVar *Data, KeyIdVar Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar DestroyNotify, OldDestroyVar *DestroyNotify) bool {
161			191
162	-	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, NewCallbackNullable(DestroyVar), OldDestroyVar)	192	+	var DestroyVarRef uintptr
			193	+	if DestroyVar != nil {
			194	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			195	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
			196	+	DestroyVarRef = cbRefPtr
			197	+	} else {
			198	+	fcb := func(arg0 uintptr) {
			199	+	cbFn := *DestroyVar
			200	+	cbFn(arg0)
			201	+	}
			202	+	DestroyVarRef = purego.NewCallback(fcb)
			203	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
			204	+	}
			205	+	}
			206	+
			207	+	cret := xDatalistIdReplaceData(DatalistVar, KeyIdVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
163		return cret	208		return cret
164		}	209		}
165			210

@@ -171,7 +216,22 @@ var xDatalistIdSetDataFull func(**Data, Quark, uintptr, uintptr)
171		// function is called.	216		// function is called.
172		func DatalistIdSetDataFull(DatalistVar *Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar DestroyNotify) {	217		func DatalistIdSetDataFull(DatalistVar *Data, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar DestroyNotify) {
173			218
174	-	xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, NewCallbackNullable(DestroyFuncVar))	219	+	var DestroyFuncVarRef uintptr
			220	+	if DestroyFuncVar != nil {
			221	+	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
			222	+	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
			223	+	DestroyFuncVarRef = cbRefPtr
			224	+	} else {
			225	+	fcb := func(arg0 uintptr) {
			226	+	cbFn := *DestroyFuncVar
			227	+	cbFn(arg0)
			228	+	}
			229	+	DestroyFuncVarRef = purego.NewCallback(fcb)
			230	+	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
			231	+	}
			232	+	}
			233	+
			234	+	xDatalistIdSetDataFull(DatalistVar, KeyIdVar, DataVar, DestroyFuncVarRef)
175			235
176		}	236		}
177			237

@@ -230,7 +290,22 @@ var xDatasetForeach func(uintptr, uintptr, uintptr)
230		// than skipping over elements that are removed.	290		// than skipping over elements that are removed.
231		func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {	291		func DatasetForeach(DatasetLocationVar uintptr, FuncVar *DataForeachFunc, UserDataVar uintptr) {
232			292
233	-	xDatasetForeach(DatasetLocationVar, NewCallback(FuncVar), UserDataVar)	293	+	var FuncVarRef uintptr
			294	+	if FuncVar != nil {
			295	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			296	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			297	+	FuncVarRef = cbRefPtr
			298	+	} else {
			299	+	fcb := func(arg0 Quark, arg1 uintptr, arg2 uintptr) {
			300	+	cbFn := *FuncVar
			301	+	cbFn(arg0, arg1, arg2)
			302	+	}
			303	+	FuncVarRef = purego.NewCallback(fcb)
			304	+	SaveCallback(FuncVarPtr, FuncVarRef)
			305	+	}
			306	+	}
			307	+
			308	+	xDatasetForeach(DatasetLocationVar, FuncVarRef, UserDataVar)
234			309
235		}	310		}
236			311

@@ -261,7 +336,22 @@ var xDatasetIdSetDataFull func(uintptr, Quark, uintptr, uintptr)
261		// is called.	336		// is called.
262		func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {	337		func DatasetIdSetDataFull(DatasetLocationVar uintptr, KeyIdVar Quark, DataVar uintptr, DestroyFuncVar *DestroyNotify) {
263			338
264	-	xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, NewCallback(DestroyFuncVar))	339	+	var DestroyFuncVarRef uintptr
			340	+	if DestroyFuncVar != nil {
			341	+	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
			342	+	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
			343	+	DestroyFuncVarRef = cbRefPtr
			344	+	} else {
			345	+	fcb := func(arg0 uintptr) {
			346	+	cbFn := *DestroyFuncVar
			347	+	cbFn(arg0)
			348	+	}
			349	+	DestroyFuncVarRef = purego.NewCallback(fcb)
			350	+	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
			351	+	}
			352	+	}
			353	+
			354	+	xDatasetIdSetDataFull(DatasetLocationVar, KeyIdVar, DataVar, DestroyFuncVarRef)
265			355
266		}	356		}
267			357

M v4/glib/gerror.go +92 -2


@@ -149,7 +149,52 @@ var xErrorDomainRegister func(string, uint, uintptr, uintptr, uintptr) Quark
149		// g_error_domain_register_static().	149		// g_error_domain_register_static().
150		func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {	150		func ErrorDomainRegister(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
151			151
152	-	cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, NewCallback(ErrorTypeInitVar), NewCallback(ErrorTypeCopyVar), NewCallback(ErrorTypeClearVar))	152	+	var ErrorTypeInitVarRef uintptr
			153	+	if ErrorTypeInitVar != nil {
			154	+	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
			155	+	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
			156	+	ErrorTypeInitVarRef = cbRefPtr
			157	+	} else {
			158	+	fcb := func(arg0 *Error) {
			159	+	cbFn := *ErrorTypeInitVar
			160	+	cbFn(arg0)
			161	+	}
			162	+	ErrorTypeInitVarRef = purego.NewCallback(fcb)
			163	+	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
			164	+	}
			165	+	}
			166	+
			167	+	var ErrorTypeCopyVarRef uintptr
			168	+	if ErrorTypeCopyVar != nil {
			169	+	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
			170	+	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
			171	+	ErrorTypeCopyVarRef = cbRefPtr
			172	+	} else {
			173	+	fcb := func(arg0 Error, arg1 Error) {
			174	+	cbFn := *ErrorTypeCopyVar
			175	+	cbFn(arg0, arg1)
			176	+	}
			177	+	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
			178	+	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
			179	+	}
			180	+	}
			181	+
			182	+	var ErrorTypeClearVarRef uintptr
			183	+	if ErrorTypeClearVar != nil {
			184	+	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
			185	+	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
			186	+	ErrorTypeClearVarRef = cbRefPtr
			187	+	} else {
			188	+	fcb := func(arg0 *Error) {
			189	+	cbFn := *ErrorTypeClearVar
			190	+	cbFn(arg0)
			191	+	}
			192	+	ErrorTypeClearVarRef = purego.NewCallback(fcb)
			193	+	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
			194	+	}
			195	+	}
			196	+
			197	+	cret := xErrorDomainRegister(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
153		return cret	198		return cret
154		}	199		}
155			200

@@ -174,7 +219,52 @@ var xErrorDomainRegisterStatic func(string, uint, uintptr, uintptr, uintptr) Qua
174		// already takes care of passing valid information to this function.	219		// already takes care of passing valid information to this function.
175		func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {	220		func ErrorDomainRegisterStatic(ErrorTypeNameVar string, ErrorTypePrivateSizeVar uint, ErrorTypeInitVar ErrorInitFunc, ErrorTypeCopyVar ErrorCopyFunc, ErrorTypeClearVar *ErrorClearFunc) Quark {
176			221
177	-	cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, NewCallback(ErrorTypeInitVar), NewCallback(ErrorTypeCopyVar), NewCallback(ErrorTypeClearVar))	222	+	var ErrorTypeInitVarRef uintptr
			223	+	if ErrorTypeInitVar != nil {
			224	+	ErrorTypeInitVarPtr := uintptr(unsafe.Pointer(ErrorTypeInitVar))
			225	+	if cbRefPtr, ok := GetCallback(ErrorTypeInitVarPtr); ok {
			226	+	ErrorTypeInitVarRef = cbRefPtr
			227	+	} else {
			228	+	fcb := func(arg0 *Error) {
			229	+	cbFn := *ErrorTypeInitVar
			230	+	cbFn(arg0)
			231	+	}
			232	+	ErrorTypeInitVarRef = purego.NewCallback(fcb)
			233	+	SaveCallback(ErrorTypeInitVarPtr, ErrorTypeInitVarRef)
			234	+	}
			235	+	}
			236	+
			237	+	var ErrorTypeCopyVarRef uintptr
			238	+	if ErrorTypeCopyVar != nil {
			239	+	ErrorTypeCopyVarPtr := uintptr(unsafe.Pointer(ErrorTypeCopyVar))
			240	+	if cbRefPtr, ok := GetCallback(ErrorTypeCopyVarPtr); ok {
			241	+	ErrorTypeCopyVarRef = cbRefPtr
			242	+	} else {
			243	+	fcb := func(arg0 Error, arg1 Error) {
			244	+	cbFn := *ErrorTypeCopyVar
			245	+	cbFn(arg0, arg1)
			246	+	}
			247	+	ErrorTypeCopyVarRef = purego.NewCallback(fcb)
			248	+	SaveCallback(ErrorTypeCopyVarPtr, ErrorTypeCopyVarRef)
			249	+	}
			250	+	}
			251	+
			252	+	var ErrorTypeClearVarRef uintptr
			253	+	if ErrorTypeClearVar != nil {
			254	+	ErrorTypeClearVarPtr := uintptr(unsafe.Pointer(ErrorTypeClearVar))
			255	+	if cbRefPtr, ok := GetCallback(ErrorTypeClearVarPtr); ok {
			256	+	ErrorTypeClearVarRef = cbRefPtr
			257	+	} else {
			258	+	fcb := func(arg0 *Error) {
			259	+	cbFn := *ErrorTypeClearVar
			260	+	cbFn(arg0)
			261	+	}
			262	+	ErrorTypeClearVarRef = purego.NewCallback(fcb)
			263	+	SaveCallback(ErrorTypeClearVarPtr, ErrorTypeClearVarRef)
			264	+	}
			265	+	}
			266	+
			267	+	cret := xErrorDomainRegisterStatic(ErrorTypeNameVar, ErrorTypePrivateSizeVar, ErrorTypeInitVarRef, ErrorTypeCopyVarRef, ErrorTypeClearVarRef)
178		return cret	268		return cret
179		}	269		}
180			270

M v4/glib/gfileutils.go +9 -9


@@ -282,7 +282,7 @@ func BuildPathv(SeparatorVar string, ArgsVar []string) string {
282		return cret	282		return cret
283		}	283		}
284			284
285	-	var xCanonicalizeFilename func(string, string) string	285	+	var xCanonicalizeFilename func(string, uintptr) string
286			286
287		// Gets the canonical file name from @filename. All triple slashes are turned into	287		// Gets the canonical file name from @filename. All triple slashes are turned into
288		// single slashes, and all `..` and `.`s resolved against @relative_to.	288		// single slashes, and all `..` and `.`s resolved against @relative_to.

@@ -298,13 +298,13 @@ var xCanonicalizeFilename func(string, string) string
298		// exist.	298		// exist.
299		//	299		//
300		// No file system I/O is done.	300		// No file system I/O is done.
301	-	func CanonicalizeFilename(FilenameVar string, RelativeToVar string) string {	301	+	func CanonicalizeFilename(FilenameVar string, RelativeToVar *string) string {
302			302
303	-	cret := xCanonicalizeFilename(FilenameVar, RelativeToVar)	303	+	cret := xCanonicalizeFilename(FilenameVar, core.NullableStringToPtr(RelativeToVar))
304		return cret	304		return cret
305		}	305		}
306			306
307	-	var xDirMakeTmp func(string, **Error) string	307	+	var xDirMakeTmp func(uintptr, **Error) string
308			308
309		// Creates a subdirectory in the preferred directory for temporary	309		// Creates a subdirectory in the preferred directory for temporary
310		// files (as returned by g_get_tmp_dir()).	310		// files (as returned by g_get_tmp_dir()).

@@ -317,10 +317,10 @@ var xDirMakeTmp func(string, **Error) string
317		//	317		//
318		// Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not	318		// Note that in contrast to g_mkdtemp() (and mkdtemp()) @tmpl is not
319		// modified, and might thus be a read-only literal string.	319		// modified, and might thus be a read-only literal string.
320	-	func DirMakeTmp(TmplVar string) (string, error) {	320	+	func DirMakeTmp(TmplVar *string) (string, error) {
321		var cerr *Error	321		var cerr *Error
322			322
323	-	cret := xDirMakeTmp(TmplVar, &cerr)	323	+	cret := xDirMakeTmp(core.NullableStringToPtr(TmplVar), &cerr)
324		if cerr == nil {	324		if cerr == nil {
325		return cret, nil	325		return cret, nil
326		}	326		}

@@ -368,7 +368,7 @@ func FileGetContents(FilenameVar string, ContentsVar []byte, LengthVar uint) (
368			368
369		}	369		}
370			370
371	-	var xFileOpenTmp func(string, string, *Error) int	371	+	var xFileOpenTmp func(uintptr, string, *Error) int
372			372
373		// Opens a file for writing in the preferred directory for temporary	373		// Opens a file for writing in the preferred directory for temporary
374		// files (as returned by g_get_tmp_dir()).	374		// files (as returned by g_get_tmp_dir()).

@@ -386,10 +386,10 @@ var xFileOpenTmp func(string, string, *Error) int
386		// is returned in @name_used. This string should be freed with g_free()	386		// is returned in @name_used. This string should be freed with g_free()
387		// when not needed any longer. The returned name is in the GLib file	387		// when not needed any longer. The returned name is in the GLib file
388		// name encoding.	388		// name encoding.
389	-	func FileOpenTmp(TmplVar string, NameUsedVar *string) (int, error) {	389	+	func FileOpenTmp(TmplVar string, NameUsedVar string) (int, error) {
390		var cerr *Error	390		var cerr *Error
391			391
392	-	cret := xFileOpenTmp(TmplVar, NameUsedVar, &cerr)	392	+	cret := xFileOpenTmp(core.NullableStringToPtr(TmplVar), NameUsedVar, &cerr)
393		if cerr == nil {	393		if cerr == nil {
394		return cret, nil	394		return cret, nil
395		}	395		}

M v4/glib/ggettext.go +15 -15


@@ -6,19 +6,19 @@ import (
6		"github.com/jwijenbergh/puregotk/pkg/core"	6		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	7		)
8			8
9	-	var xDcgettext func(string, string, int) string	9	+	var xDcgettext func(uintptr, string, int) string
10			10
11		// This is a variant of g_dgettext() that allows specifying a locale	11		// This is a variant of g_dgettext() that allows specifying a locale
12		// category instead of always using `LC_MESSAGES`. See g_dgettext() for	12		// category instead of always using `LC_MESSAGES`. See g_dgettext() for
13		// more information about how this functions differs from calling	13		// more information about how this functions differs from calling
14		// dcgettext() directly.	14		// dcgettext() directly.
15	-	func Dcgettext(DomainVar string, MsgidVar string, CategoryVar int) string {	15	+	func Dcgettext(DomainVar *string, MsgidVar string, CategoryVar int) string {
16			16
17	-	cret := xDcgettext(DomainVar, MsgidVar, CategoryVar)	17	+	cret := xDcgettext(core.NullableStringToPtr(DomainVar), MsgidVar, CategoryVar)
18		return cret	18		return cret
19		}	19		}
20			20
21	-	var xDgettext func(string, string) string	21	+	var xDgettext func(uintptr, string) string
22			22
23		// This function is a wrapper of dgettext() which does not translate	23		// This function is a wrapper of dgettext() which does not translate
24		// the message if the default domain as set with textdomain() has no	24		// the message if the default domain as set with textdomain() has no

@@ -52,13 +52,13 @@ var xDgettext func(string, string) string
52		//	52		//
53		// Applications should normally not use this function directly,	53		// Applications should normally not use this function directly,
54		// but use the _() macro for translations.	54		// but use the _() macro for translations.
55	-	func Dgettext(DomainVar string, MsgidVar string) string {	55	+	func Dgettext(DomainVar *string, MsgidVar string) string {
56			56
57	-	cret := xDgettext(DomainVar, MsgidVar)	57	+	cret := xDgettext(core.NullableStringToPtr(DomainVar), MsgidVar)
58		return cret	58		return cret
59		}	59		}
60			60
61	-	var xDngettext func(string, string, string, uint32) string	61	+	var xDngettext func(uintptr, string, string, uint32) string
62			62
63		// This function is a wrapper of dngettext() which does not translate	63		// This function is a wrapper of dngettext() which does not translate
64		// the message if the default domain as set with textdomain() has no	64		// the message if the default domain as set with textdomain() has no

@@ -66,13 +66,13 @@ var xDngettext func(string, string, string, uint32) string
66		//	66		//
67		// See g_dgettext() for details of how this differs from dngettext()	67		// See g_dgettext() for details of how this differs from dngettext()
68		// proper.	68		// proper.
69	-	func Dngettext(DomainVar string, MsgidVar string, MsgidPluralVar string, NVar uint32) string {	69	+	func Dngettext(DomainVar *string, MsgidVar string, MsgidPluralVar string, NVar uint32) string {
70			70
71	-	cret := xDngettext(DomainVar, MsgidVar, MsgidPluralVar, NVar)	71	+	cret := xDngettext(core.NullableStringToPtr(DomainVar), MsgidVar, MsgidPluralVar, NVar)
72		return cret	72		return cret
73		}	73		}
74			74
75	-	var xDpgettext func(string, string, uint) string	75	+	var xDpgettext func(uintptr, string, uint) string
76			76
77		// This function is a variant of g_dgettext() which supports	77		// This function is a variant of g_dgettext() which supports
78		// a disambiguating message context. GNU gettext uses the	78		// a disambiguating message context. GNU gettext uses the

@@ -87,13 +87,13 @@ var xDpgettext func(string, string, uint) string
87		//	87		//
88		// Applications should normally not use this function directly,	88		// Applications should normally not use this function directly,
89		// but use the C_() macro for translations with context.	89		// but use the C_() macro for translations with context.
90	-	func Dpgettext(DomainVar string, MsgctxtidVar string, MsgidoffsetVar uint) string {	90	+	func Dpgettext(DomainVar *string, MsgctxtidVar string, MsgidoffsetVar uint) string {
91			91
92	-	cret := xDpgettext(DomainVar, MsgctxtidVar, MsgidoffsetVar)	92	+	cret := xDpgettext(core.NullableStringToPtr(DomainVar), MsgctxtidVar, MsgidoffsetVar)
93		return cret	93		return cret
94		}	94		}
95			95
96	-	var xDpgettext2 func(string, string, string) string	96	+	var xDpgettext2 func(uintptr, string, string) string
97			97
98		// This function is a variant of g_dgettext() which supports	98		// This function is a variant of g_dgettext() which supports
99		// a disambiguating message context. GNU gettext uses the	99		// a disambiguating message context. GNU gettext uses the

@@ -105,9 +105,9 @@ var xDpgettext2 func(string, string, string) string
105		//	105		//
106		// This function differs from C_() in that it is not a macro and	106		// This function differs from C_() in that it is not a macro and
107		// thus you may use non-string-literals as context and msgid arguments.	107		// thus you may use non-string-literals as context and msgid arguments.
108	-	func Dpgettext2(DomainVar string, ContextVar string, MsgidVar string) string {	108	+	func Dpgettext2(DomainVar *string, ContextVar string, MsgidVar string) string {
109			109
110	-	cret := xDpgettext2(DomainVar, ContextVar, MsgidVar)	110	+	cret := xDpgettext2(core.NullableStringToPtr(DomainVar), ContextVar, MsgidVar)
111		return cret	111		return cret
112		}	112		}
113			113

M v4/glib/ghash.go +64 -4


@@ -286,7 +286,22 @@ var xHashTableFind func(*HashTable, uintptr, uintptr) uintptr
286		// values in a hash table ends up needing O(n*n) operations).	286		// values in a hash table ends up needing O(n*n) operations).
287		func HashTableFind(HashTableVar HashTable, PredicateVar HRFunc, UserDataVar uintptr) uintptr {	287		func HashTableFind(HashTableVar HashTable, PredicateVar HRFunc, UserDataVar uintptr) uintptr {
288			288
289	-	cret := xHashTableFind(HashTableVar, NewCallback(PredicateVar), UserDataVar)	289	+	var PredicateVarRef uintptr
			290	+	if PredicateVar != nil {
			291	+	PredicateVarPtr := uintptr(unsafe.Pointer(PredicateVar))
			292	+	if cbRefPtr, ok := GetCallback(PredicateVarPtr); ok {
			293	+	PredicateVarRef = cbRefPtr
			294	+	} else {
			295	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			296	+	cbFn := *PredicateVar
			297	+	return cbFn(arg0, arg1, arg2)
			298	+	}
			299	+	PredicateVarRef = purego.NewCallback(fcb)
			300	+	SaveCallback(PredicateVarPtr, PredicateVarRef)
			301	+	}
			302	+	}
			303	+
			304	+	cret := xHashTableFind(HashTableVar, PredicateVarRef, UserDataVar)
290		return cret	305		return cret
291		}	306		}
292			307

@@ -306,7 +321,22 @@ var xHashTableForeach func(*HashTable, uintptr, uintptr)
306		// order searches in contrast to g_hash_table_lookup().	321		// order searches in contrast to g_hash_table_lookup().
307		func HashTableForeach(HashTableVar HashTable, FuncVar HFunc, UserDataVar uintptr) {	322		func HashTableForeach(HashTableVar HashTable, FuncVar HFunc, UserDataVar uintptr) {
308			323
309	-	xHashTableForeach(HashTableVar, NewCallback(FuncVar), UserDataVar)	324	+	var FuncVarRef uintptr
			325	+	if FuncVar != nil {
			326	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			327	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			328	+	FuncVarRef = cbRefPtr
			329	+	} else {
			330	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			331	+	cbFn := *FuncVar
			332	+	cbFn(arg0, arg1, arg2)
			333	+	}
			334	+	FuncVarRef = purego.NewCallback(fcb)
			335	+	SaveCallback(FuncVarPtr, FuncVarRef)
			336	+	}
			337	+	}
			338	+
			339	+	xHashTableForeach(HashTableVar, FuncVarRef, UserDataVar)
310			340
311		}	341		}
312			342

@@ -322,7 +352,22 @@ var xHashTableForeachRemove func(*HashTable, uintptr, uintptr) uint
322		// key/value pairs in the hash table.	352		// key/value pairs in the hash table.
323		func HashTableForeachRemove(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {	353		func HashTableForeachRemove(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {
324			354
325	-	cret := xHashTableForeachRemove(HashTableVar, NewCallback(FuncVar), UserDataVar)	355	+	var FuncVarRef uintptr
			356	+	if FuncVar != nil {
			357	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			358	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			359	+	FuncVarRef = cbRefPtr
			360	+	} else {
			361	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			362	+	cbFn := *FuncVar
			363	+	return cbFn(arg0, arg1, arg2)
			364	+	}
			365	+	FuncVarRef = purego.NewCallback(fcb)
			366	+	SaveCallback(FuncVarPtr, FuncVarRef)
			367	+	}
			368	+	}
			369	+
			370	+	cret := xHashTableForeachRemove(HashTableVar, FuncVarRef, UserDataVar)
326		return cret	371		return cret
327		}	372		}
328			373

@@ -337,7 +382,22 @@ var xHashTableForeachSteal func(*HashTable, uintptr, uintptr) uint
337		// key/value pairs in the hash table.	382		// key/value pairs in the hash table.
338		func HashTableForeachSteal(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {	383		func HashTableForeachSteal(HashTableVar HashTable, FuncVar HRFunc, UserDataVar uintptr) uint {
339			384
340	-	cret := xHashTableForeachSteal(HashTableVar, NewCallback(FuncVar), UserDataVar)	385	+	var FuncVarRef uintptr
			386	+	if FuncVar != nil {
			387	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			388	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			389	+	FuncVarRef = cbRefPtr
			390	+	} else {
			391	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			392	+	cbFn := *FuncVar
			393	+	return cbFn(arg0, arg1, arg2)
			394	+	}
			395	+	FuncVarRef = purego.NewCallback(fcb)
			396	+	SaveCallback(FuncVarPtr, FuncVarRef)
			397	+	}
			398	+	}
			399	+
			400	+	cret := xHashTableForeachSteal(HashTableVar, FuncVarRef, UserDataVar)
341		return cret	401		return cret
342		}	402		}
343			403

M v4/glib/ghook.go +48 -3


@@ -135,7 +135,22 @@ var xHookListMarshal func(uintptr, bool, uintptr, uintptr)
135		// Calls a function on each valid #GHook.	135		// Calls a function on each valid #GHook.
136		func (x HookList) Marshal(MayRecurseVar bool, MarshallerVar HookMarshaller, MarshalDataVar uintptr) {	136		func (x HookList) Marshal(MayRecurseVar bool, MarshallerVar HookMarshaller, MarshalDataVar uintptr) {
137			137
138	-	xHookListMarshal(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)	138	+	var MarshallerVarRef uintptr
			139	+	if MarshallerVar != nil {
			140	+	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
			141	+	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
			142	+	MarshallerVarRef = cbRefPtr
			143	+	} else {
			144	+	fcb := func(arg0 *Hook, arg1 uintptr) {
			145	+	cbFn := *MarshallerVar
			146	+	cbFn(arg0, arg1)
			147	+	}
			148	+	MarshallerVarRef = purego.NewCallback(fcb)
			149	+	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
			150	+	}
			151	+	}
			152	+
			153	+	xHookListMarshal(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
139			154
140		}	155		}
141			156

@@ -145,7 +160,22 @@ var xHookListMarshalCheck func(uintptr, bool, uintptr, uintptr)
145		// function returns %FALSE.	160		// function returns %FALSE.
146		func (x HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar HookCheckMarshaller, MarshalDataVar uintptr) {	161		func (x HookList) MarshalCheck(MayRecurseVar bool, MarshallerVar HookCheckMarshaller, MarshalDataVar uintptr) {
147			162
148	-	xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, NewCallback(MarshallerVar), MarshalDataVar)	163	+	var MarshallerVarRef uintptr
			164	+	if MarshallerVar != nil {
			165	+	MarshallerVarPtr := uintptr(unsafe.Pointer(MarshallerVar))
			166	+	if cbRefPtr, ok := GetCallback(MarshallerVarPtr); ok {
			167	+	MarshallerVarRef = cbRefPtr
			168	+	} else {
			169	+	fcb := func(arg0 *Hook, arg1 uintptr) bool {
			170	+	cbFn := *MarshallerVar
			171	+	return cbFn(arg0, arg1)
			172	+	}
			173	+	MarshallerVarRef = purego.NewCallback(fcb)
			174	+	SaveCallback(MarshallerVarPtr, MarshallerVarRef)
			175	+	}
			176	+	}
			177	+
			178	+	xHookListMarshalCheck(x.GoPointer(), MayRecurseVar, MarshallerVarRef, MarshalDataVar)
149			179
150		}	180		}
151			181

@@ -214,7 +244,22 @@ var xHookInsertSorted func(HookList, Hook, uintptr)
214		// Inserts a #GHook into a #GHookList, sorted by the given function.	244		// Inserts a #GHook into a #GHookList, sorted by the given function.
215		func HookInsertSorted(HookListVar HookList, HookVar Hook, FuncVar *HookCompareFunc) {	245		func HookInsertSorted(HookListVar HookList, HookVar Hook, FuncVar *HookCompareFunc) {
216			246
217	-	xHookInsertSorted(HookListVar, HookVar, NewCallback(FuncVar))	247	+	var FuncVarRef uintptr
			248	+	if FuncVar != nil {
			249	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			250	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			251	+	FuncVarRef = cbRefPtr
			252	+	} else {
			253	+	fcb := func(arg0 Hook, arg1 Hook) int {
			254	+	cbFn := *FuncVar
			255	+	return cbFn(arg0, arg1)
			256	+	}
			257	+	FuncVarRef = purego.NewCallback(fcb)
			258	+	SaveCallback(FuncVarPtr, FuncVarRef)
			259	+	}
			260	+	}
			261	+
			262	+	xHookInsertSorted(HookListVar, HookVar, FuncVarRef)
218			263
219		}	264		}
220			265

M v4/glib/giochannel.go +53 -8


@@ -438,7 +438,7 @@ func (x *IOChannel) SetCloseOnUnref(DoCloseVar bool) {
438			438
439		}	439		}
440			440
441	-	var xIOChannelSetEncoding func(uintptr, string, **Error) IOStatus	441	+	var xIOChannelSetEncoding func(uintptr, uintptr, **Error) IOStatus
442			442
443		// Sets the encoding for the input/output of the channel.	443		// Sets the encoding for the input/output of the channel.
444		// The internal encoding is always UTF-8. The default encoding	444		// The internal encoding is always UTF-8. The default encoding

@@ -474,10 +474,10 @@ var xIOChannelSetEncoding func(uintptr, string, **Error) IOStatus
474		// g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if	474		// g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if
475		// they are "seekable", cannot call g_io_channel_write_chars() after	475		// they are "seekable", cannot call g_io_channel_write_chars() after
476		// calling one of the API "read" functions.	476		// calling one of the API "read" functions.
477	-	func (x *IOChannel) SetEncoding(EncodingVar string) (IOStatus, error) {	477	+	func (x IOChannel) SetEncoding(EncodingVar string) (IOStatus, error) {
478		var cerr *Error	478		var cerr *Error
479			479
480	-	cret := xIOChannelSetEncoding(x.GoPointer(), EncodingVar, &cerr)	480	+	cret := xIOChannelSetEncoding(x.GoPointer(), core.NullableStringToPtr(EncodingVar), &cerr)
481		if cerr == nil {	481		if cerr == nil {
482		return cret, nil	482		return cret, nil
483		}	483		}

@@ -499,13 +499,13 @@ func (x *IOChannel) SetFlags(FlagsVar IOFlags) (IOStatus, error) {
499			499
500		}	500		}
501			501
502	-	var xIOChannelSetLineTerm func(uintptr, string, int)	502	+	var xIOChannelSetLineTerm func(uintptr, uintptr, int)
503			503
504		// This sets the string that #GIOChannel uses to determine	504		// This sets the string that #GIOChannel uses to determine
505		// where in the file a line break occurs.	505		// where in the file a line break occurs.
506	-	func (x *IOChannel) SetLineTerm(LineTermVar string, LengthVar int) {	506	+	func (x IOChannel) SetLineTerm(LineTermVar string, LengthVar int) {
507			507
508	-	xIOChannelSetLineTerm(x.GoPointer(), LineTermVar, LengthVar)	508	+	xIOChannelSetLineTerm(x.GoPointer(), core.NullableStringToPtr(LineTermVar), LengthVar)
509			509
510		}	510		}
511			511

@@ -1018,7 +1018,22 @@ var xIoAddWatch func(*IOChannel, IOCondition, uintptr, uintptr) uint
1018		// with the default priority.	1018		// with the default priority.
1019		func IoAddWatch(ChannelVar IOChannel, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr) uint {	1019		func IoAddWatch(ChannelVar IOChannel, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr) uint {
1020			1020
1021	-	cret := xIoAddWatch(ChannelVar, ConditionVar, NewCallback(FuncVar), UserDataVar)	1021	+	var FuncVarRef uintptr
			1022	+	if FuncVar != nil {
			1023	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			1024	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			1025	+	FuncVarRef = cbRefPtr
			1026	+	} else {
			1027	+	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
			1028	+	cbFn := *FuncVar
			1029	+	return cbFn(arg0, arg1, arg2)
			1030	+	}
			1031	+	FuncVarRef = purego.NewCallback(fcb)
			1032	+	SaveCallback(FuncVarPtr, FuncVarRef)
			1033	+	}
			1034	+	}
			1035	+
			1036	+	cret := xIoAddWatch(ChannelVar, ConditionVar, FuncVarRef, UserDataVar)
1022		return cret	1037		return cret
1023		}	1038		}
1024			1039

@@ -1032,7 +1047,37 @@ var xIoAddWatchFull func(*IOChannel, int, IOCondition, uintptr, uintptr, uintptr
1032		// You can do these steps manually if you need greater control.	1047		// You can do these steps manually if you need greater control.
1033		func IoAddWatchFull(ChannelVar IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {	1048		func IoAddWatchFull(ChannelVar IOChannel, PriorityVar int, ConditionVar IOCondition, FuncVar IOFunc, UserDataVar uintptr, NotifyVar *DestroyNotify) uint {
1034			1049
1035	-	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, NewCallback(FuncVar), UserDataVar, NewCallback(NotifyVar))	1050	+	var FuncVarRef uintptr
			1051	+	if FuncVar != nil {
			1052	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			1053	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			1054	+	FuncVarRef = cbRefPtr
			1055	+	} else {
			1056	+	fcb := func(arg0 *IOChannel, arg1 IOCondition, arg2 uintptr) bool {
			1057	+	cbFn := *FuncVar
			1058	+	return cbFn(arg0, arg1, arg2)
			1059	+	}
			1060	+	FuncVarRef = purego.NewCallback(fcb)
			1061	+	SaveCallback(FuncVarPtr, FuncVarRef)
			1062	+	}
			1063	+	}
			1064	+
			1065	+	var NotifyVarRef uintptr
			1066	+	if NotifyVar != nil {
			1067	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1068	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			1069	+	NotifyVarRef = cbRefPtr
			1070	+	} else {
			1071	+	fcb := func(arg0 uintptr) {
			1072	+	cbFn := *NotifyVar
			1073	+	cbFn(arg0)
			1074	+	}
			1075	+	NotifyVarRef = purego.NewCallback(fcb)
			1076	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			1077	+	}
			1078	+	}
			1079	+
			1080	+	cret := xIoAddWatchFull(ChannelVar, PriorityVar, ConditionVar, FuncVarRef, UserDataVar, NotifyVarRef)
1036		return cret	1081		return cret
1037		}	1082		}
1038			1083

M v4/glib/gkeyfile.go +18 -18


@@ -230,7 +230,7 @@ func (x KeyFile) GetBooleanList(GroupNameVar string, KeyVar string, LengthVar
230			230
231		}	231		}
232			232
233	-	var xKeyFileGetComment func(uintptr, string, string, **Error) string	233	+	var xKeyFileGetComment func(uintptr, uintptr, uintptr, **Error) string
234			234
235		// Retrieves a comment above @key from @group_name.	235		// Retrieves a comment above @key from @group_name.
236		//	236		//

@@ -241,10 +241,10 @@ var xKeyFileGetComment func(uintptr, string, string, **Error) string
241		// Note that the returned string does not include the `#` comment markers,	241		// Note that the returned string does not include the `#` comment markers,
242		// but does include any whitespace after them (on each line). It includes	242		// but does include any whitespace after them (on each line). It includes
243		// the line breaks between lines, but does not include the final line break.	243		// the line breaks between lines, but does not include the final line break.
244	-	func (x *KeyFile) GetComment(GroupNameVar string, KeyVar string) (string, error) {	244	+	func (x KeyFile) GetComment(GroupNameVar string, KeyVar *string) (string, error) {
245		var cerr *Error	245		var cerr *Error
246			246
247	-	cret := xKeyFileGetComment(x.GoPointer(), GroupNameVar, KeyVar, &cerr)	247	+	cret := xKeyFileGetComment(x.GoPointer(), core.NullableStringToPtr(GroupNameVar), core.NullableStringToPtr(KeyVar), &cerr)
248		if cerr == nil {	248		if cerr == nil {
249		return cret, nil	249		return cret, nil
250		}	250		}

@@ -377,7 +377,7 @@ func (x KeyFile) GetKeys(GroupNameVar string, LengthVar uint) ([]string, error
377			377
378		}	378		}
379			379
380	-	var xKeyFileGetLocaleForKey func(uintptr, string, string, string) string	380	+	var xKeyFileGetLocaleForKey func(uintptr, string, string, uintptr) string
381			381
382		// Returns the actual locale which the result of	382		// Returns the actual locale which the result of
383		// [method@GLib.KeyFile.get_locale_string] or	383		// [method@GLib.KeyFile.get_locale_string] or

@@ -388,13 +388,13 @@ var xKeyFileGetLocaleForKey func(uintptr, string, string, string) string
388		// @group_name, @key and @locale, the result of those functions will	388		// @group_name, @key and @locale, the result of those functions will
389		// have originally been tagged with the locale that is the result of	389		// have originally been tagged with the locale that is the result of
390		// this function.	390		// this function.
391	-	func (x *KeyFile) GetLocaleForKey(GroupNameVar string, KeyVar string, LocaleVar string) string {	391	+	func (x KeyFile) GetLocaleForKey(GroupNameVar string, KeyVar string, LocaleVar string) string {
392			392
393	-	cret := xKeyFileGetLocaleForKey(x.GoPointer(), GroupNameVar, KeyVar, LocaleVar)	393	+	cret := xKeyFileGetLocaleForKey(x.GoPointer(), GroupNameVar, KeyVar, core.NullableStringToPtr(LocaleVar))
394		return cret	394		return cret
395		}	395		}
396			396
397	-	var xKeyFileGetLocaleString func(uintptr, string, string, string, **Error) string	397	+	var xKeyFileGetLocaleString func(uintptr, string, string, uintptr, **Error) string
398			398
399		// Returns the value associated with @key under @group_name	399		// Returns the value associated with @key under @group_name
400		// translated in the given @locale if available.	400		// translated in the given @locale if available.

@@ -412,10 +412,10 @@ var xKeyFileGetLocaleString func(uintptr, string, string, string, **Error) strin
412		// returned. If the value associated	412		// returned. If the value associated
413		// with @key cannot be interpreted or no suitable translation can	413		// with @key cannot be interpreted or no suitable translation can
414		// be found then the untranslated value is returned.	414		// be found then the untranslated value is returned.
415	-	func (x *KeyFile) GetLocaleString(GroupNameVar string, KeyVar string, LocaleVar string) (string, error) {	415	+	func (x KeyFile) GetLocaleString(GroupNameVar string, KeyVar string, LocaleVar string) (string, error) {
416		var cerr *Error	416		var cerr *Error
417			417
418	-	cret := xKeyFileGetLocaleString(x.GoPointer(), GroupNameVar, KeyVar, LocaleVar, &cerr)	418	+	cret := xKeyFileGetLocaleString(x.GoPointer(), GroupNameVar, KeyVar, core.NullableStringToPtr(LocaleVar), &cerr)
419		if cerr == nil {	419		if cerr == nil {
420		return cret, nil	420		return cret, nil
421		}	421		}

@@ -423,7 +423,7 @@ func (x *KeyFile) GetLocaleString(GroupNameVar string, KeyVar string, LocaleVar
423			423
424		}	424		}
425			425
426	-	var xKeyFileGetLocaleStringList func(uintptr, string, string, string, uint, *Error) []string	426	+	var xKeyFileGetLocaleStringList func(uintptr, string, string, uintptr, uint, *Error) []string
427			427
428		// Returns the values associated with @key under @group_name	428		// Returns the values associated with @key under @group_name
429		// translated in the given @locale if available.	429		// translated in the given @locale if available.

@@ -443,10 +443,10 @@ var xKeyFileGetLocaleStringList func(uintptr, string, string, string, uint, *E
443		// can be found then the untranslated values are returned. The	443		// can be found then the untranslated values are returned. The
444		// returned array is `NULL`-terminated, so @length may optionally	444		// returned array is `NULL`-terminated, so @length may optionally
445		// be `NULL`.	445		// be `NULL`.
446	-	func (x KeyFile) GetLocaleStringList(GroupNameVar string, KeyVar string, LocaleVar string, LengthVar uint) ([]string, error) {	446	+	func (x KeyFile) GetLocaleStringList(GroupNameVar string, KeyVar string, LocaleVar string, LengthVar *uint) ([]string, error) {
447		var cerr *Error	447		var cerr *Error
448			448
449	-	cret := xKeyFileGetLocaleStringList(x.GoPointer(), GroupNameVar, KeyVar, LocaleVar, LengthVar, &cerr)	449	+	cret := xKeyFileGetLocaleStringList(x.GoPointer(), GroupNameVar, KeyVar, core.NullableStringToPtr(LocaleVar), LengthVar, &cerr)
450		if cerr == nil {	450		if cerr == nil {
451		return cret, nil	451		return cret, nil
452		}	452		}

@@ -686,17 +686,17 @@ func (x KeyFile) Ref() KeyFile {
686		return cret	686		return cret
687		}	687		}
688			688
689	-	var xKeyFileRemoveComment func(uintptr, string, string, **Error) bool	689	+	var xKeyFileRemoveComment func(uintptr, uintptr, uintptr, **Error) bool
690			690
691		// Removes a comment above @key from @group_name.	691		// Removes a comment above @key from @group_name.
692		//	692		//
693		// If @key is `NULL` then @comment will be removed above @group_name.	693		// If @key is `NULL` then @comment will be removed above @group_name.
694		// If both @key and @group_name are `NULL`, then @comment will	694		// If both @key and @group_name are `NULL`, then @comment will
695		// be removed above the first group in the file.	695		// be removed above the first group in the file.
696	-	func (x *KeyFile) RemoveComment(GroupNameVar string, KeyVar string) (bool, error) {	696	+	func (x KeyFile) RemoveComment(GroupNameVar string, KeyVar *string) (bool, error) {
697		var cerr *Error	697		var cerr *Error
698			698
699	-	cret := xKeyFileRemoveComment(x.GoPointer(), GroupNameVar, KeyVar, &cerr)	699	+	cret := xKeyFileRemoveComment(x.GoPointer(), core.NullableStringToPtr(GroupNameVar), core.NullableStringToPtr(KeyVar), &cerr)
700		if cerr == nil {	700		if cerr == nil {
701		return cret, nil	701		return cret, nil
702		}	702		}

@@ -778,7 +778,7 @@ func (x *KeyFile) SetBooleanList(GroupNameVar string, KeyVar string, ListVar []b
778			778
779		}	779		}
780			780
781	-	var xKeyFileSetComment func(uintptr, string, string, string, **Error) bool	781	+	var xKeyFileSetComment func(uintptr, uintptr, uintptr, string, **Error) bool
782			782
783		// Places a comment above @key from @group_name.	783		// Places a comment above @key from @group_name.
784		//	784		//

@@ -793,10 +793,10 @@ var xKeyFileSetComment func(uintptr, string, string, string, **Error) bool
793		//	793		//
794		// Note that this function prepends a `#` comment marker to	794		// Note that this function prepends a `#` comment marker to
795		// each line of @comment.	795		// each line of @comment.
796	-	func (x *KeyFile) SetComment(GroupNameVar string, KeyVar string, CommentVar string) (bool, error) {	796	+	func (x KeyFile) SetComment(GroupNameVar string, KeyVar *string, CommentVar string) (bool, error) {
797		var cerr *Error	797		var cerr *Error
798			798
799	-	cret := xKeyFileSetComment(x.GoPointer(), GroupNameVar, KeyVar, CommentVar, &cerr)	799	+	cret := xKeyFileSetComment(x.GoPointer(), core.NullableStringToPtr(GroupNameVar), core.NullableStringToPtr(KeyVar), CommentVar, &cerr)
800		if cerr == nil {	800		if cerr == nil {
801		return cret, nil	801		return cret, nil
802		}	802		}

M v4/glib/glib-unix.go +94 -4


@@ -99,7 +99,22 @@ var xUnixFdAdd func(int, IOCondition, uintptr, uintptr) uint
99		// The source will never close the fd -- you must do it yourself.	99		// The source will never close the fd -- you must do it yourself.
100		func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {	100		func UnixFdAdd(FdVar int, ConditionVar IOCondition, FunctionVar *UnixFDSourceFunc, UserDataVar uintptr) uint {
101			101
102	-	cret := xUnixFdAdd(FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar)	102	+	var FunctionVarRef uintptr
			103	+	if FunctionVar != nil {
			104	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			105	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			106	+	FunctionVarRef = cbRefPtr
			107	+	} else {
			108	+	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
			109	+	cbFn := *FunctionVar
			110	+	return cbFn(arg0, arg1, arg2)
			111	+	}
			112	+	FunctionVarRef = purego.NewCallback(fcb)
			113	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			114	+	}
			115	+	}
			116	+
			117	+	cret := xUnixFdAdd(FdVar, ConditionVar, FunctionVarRef, UserDataVar)
103		return cret	118		return cret
104		}	119		}
105			120

@@ -113,7 +128,37 @@ var xUnixFdAddFull func(int, int, IOCondition, uintptr, uintptr, uintptr) uint
113		// @user_data.	128		// @user_data.
114		func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {	129		func UnixFdAddFull(PriorityVar int, FdVar int, ConditionVar IOCondition, FunctionVar UnixFDSourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
115			130
116	-	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, NewCallback(FunctionVar), UserDataVar, NewCallback(NotifyVar))	131	+	var FunctionVarRef uintptr
			132	+	if FunctionVar != nil {
			133	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			134	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			135	+	FunctionVarRef = cbRefPtr
			136	+	} else {
			137	+	fcb := func(arg0 int, arg1 IOCondition, arg2 uintptr) bool {
			138	+	cbFn := *FunctionVar
			139	+	return cbFn(arg0, arg1, arg2)
			140	+	}
			141	+	FunctionVarRef = purego.NewCallback(fcb)
			142	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			143	+	}
			144	+	}
			145	+
			146	+	var NotifyVarRef uintptr
			147	+	if NotifyVar != nil {
			148	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			149	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			150	+	NotifyVarRef = cbRefPtr
			151	+	} else {
			152	+	fcb := func(arg0 uintptr) {
			153	+	cbFn := *NotifyVar
			154	+	cbFn(arg0)
			155	+	}
			156	+	NotifyVarRef = purego.NewCallback(fcb)
			157	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			158	+	}
			159	+	}
			160	+
			161	+	cret := xUnixFdAddFull(PriorityVar, FdVar, ConditionVar, FunctionVarRef, UserDataVar, NotifyVarRef)
117		return cret	162		return cret
118		}	163		}
119			164

@@ -211,7 +256,22 @@ var xUnixSignalAdd func(int, uintptr, uintptr) uint
211		// using g_source_remove().	256		// using g_source_remove().
212		func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {	257		func UnixSignalAdd(SignumVar int, HandlerVar *SourceFunc, UserDataVar uintptr) uint {
213			258
214	-	cret := xUnixSignalAdd(SignumVar, NewCallback(HandlerVar), UserDataVar)	259	+	var HandlerVarRef uintptr
			260	+	if HandlerVar != nil {
			261	+	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
			262	+	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
			263	+	HandlerVarRef = cbRefPtr
			264	+	} else {
			265	+	fcb := func(arg0 uintptr) bool {
			266	+	cbFn := *HandlerVar
			267	+	return cbFn(arg0)
			268	+	}
			269	+	HandlerVarRef = purego.NewCallback(fcb)
			270	+	SaveCallback(HandlerVarPtr, HandlerVarRef)
			271	+	}
			272	+	}
			273	+
			274	+	cret := xUnixSignalAdd(SignumVar, HandlerVarRef, UserDataVar)
215		return cret	275		return cret
216		}	276		}
217			277

@@ -222,7 +282,37 @@ var xUnixSignalAddFull func(int, int, uintptr, uintptr, uintptr) uint
222		// using g_source_remove().	282		// using g_source_remove().
223		func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {	283		func UnixSignalAddFull(PriorityVar int, SignumVar int, HandlerVar SourceFunc, UserDataVar uintptr, NotifyVar DestroyNotify) uint {
224			284
225	-	cret := xUnixSignalAddFull(PriorityVar, SignumVar, NewCallback(HandlerVar), UserDataVar, NewCallback(NotifyVar))	285	+	var HandlerVarRef uintptr
			286	+	if HandlerVar != nil {
			287	+	HandlerVarPtr := uintptr(unsafe.Pointer(HandlerVar))
			288	+	if cbRefPtr, ok := GetCallback(HandlerVarPtr); ok {
			289	+	HandlerVarRef = cbRefPtr
			290	+	} else {
			291	+	fcb := func(arg0 uintptr) bool {
			292	+	cbFn := *HandlerVar
			293	+	return cbFn(arg0)
			294	+	}
			295	+	HandlerVarRef = purego.NewCallback(fcb)
			296	+	SaveCallback(HandlerVarPtr, HandlerVarRef)
			297	+	}
			298	+	}
			299	+
			300	+	var NotifyVarRef uintptr
			301	+	if NotifyVar != nil {
			302	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			303	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			304	+	NotifyVarRef = cbRefPtr
			305	+	} else {
			306	+	fcb := func(arg0 uintptr) {
			307	+	cbFn := *NotifyVar
			308	+	cbFn(arg0)
			309	+	}
			310	+	NotifyVarRef = purego.NewCallback(fcb)
			311	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			312	+	}
			313	+	}
			314	+
			315	+	cret := xUnixSignalAddFull(PriorityVar, SignumVar, HandlerVarRef, UserDataVar, NotifyVarRef)
226		return cret	316		return cret
227		}	317		}
228			318

M v4/glib/glist.go +16 -1


@@ -31,7 +31,22 @@ var xClearList func(**List, uintptr)
31		// @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.	31		// @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing.
32		func ClearList(ListPtrVar *List, DestroyVar DestroyNotify) {	32		func ClearList(ListPtrVar *List, DestroyVar DestroyNotify) {
33			33
34	-	xClearList(ListPtrVar, NewCallbackNullable(DestroyVar))	34	+	var DestroyVarRef uintptr
			35	+	if DestroyVar != nil {
			36	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			37	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
			38	+	DestroyVarRef = cbRefPtr
			39	+	} else {
			40	+	fcb := func(arg0 uintptr) {
			41	+	cbFn := *DestroyVar
			42	+	cbFn(arg0)
			43	+	}
			44	+	DestroyVarRef = purego.NewCallback(fcb)
			45	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
			46	+	}
			47	+	}
			48	+
			49	+	xClearList(ListPtrVar, DestroyVarRef)
35			50
36		}	51		}
37			52

M v4/glib/gmain.go +362 -17


@@ -279,7 +279,22 @@ var xMainContextInvoke func(uintptr, uintptr, uintptr)
279		// will be continuously run in a loop (and may prevent this call from returning).	279		// will be continuously run in a loop (and may prevent this call from returning).
280		func (x MainContext) Invoke(FunctionVar SourceFunc, DataVar uintptr) {	280		func (x MainContext) Invoke(FunctionVar SourceFunc, DataVar uintptr) {
281			281
282	-	xMainContextInvoke(x.GoPointer(), NewCallback(FunctionVar), DataVar)	282	+	var FunctionVarRef uintptr
			283	+	if FunctionVar != nil {
			284	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			285	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			286	+	FunctionVarRef = cbRefPtr
			287	+	} else {
			288	+	fcb := func(arg0 uintptr) bool {
			289	+	cbFn := *FunctionVar
			290	+	return cbFn(arg0)
			291	+	}
			292	+	FunctionVarRef = purego.NewCallback(fcb)
			293	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			294	+	}
			295	+	}
			296	+
			297	+	xMainContextInvoke(x.GoPointer(), FunctionVarRef, DataVar)
283			298
284		}	299		}
285			300

@@ -297,7 +312,37 @@ var xMainContextInvokeFull func(uintptr, int, uintptr, uintptr, uintptr)
297		// thread or with any particular context acquired.	312		// thread or with any particular context acquired.
298		func (x MainContext) InvokeFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {	313		func (x MainContext) InvokeFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
299			314
300	-	xMainContextInvokeFull(x.GoPointer(), PriorityVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))	315	+	var FunctionVarRef uintptr
			316	+	if FunctionVar != nil {
			317	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			318	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			319	+	FunctionVarRef = cbRefPtr
			320	+	} else {
			321	+	fcb := func(arg0 uintptr) bool {
			322	+	cbFn := *FunctionVar
			323	+	return cbFn(arg0)
			324	+	}
			325	+	FunctionVarRef = purego.NewCallback(fcb)
			326	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			327	+	}
			328	+	}
			329	+
			330	+	var NotifyVarRef uintptr
			331	+	if NotifyVar != nil {
			332	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			333	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			334	+	NotifyVarRef = cbRefPtr
			335	+	} else {
			336	+	fcb := func(arg0 uintptr) {
			337	+	cbFn := *NotifyVar
			338	+	cbFn(arg0)
			339	+	}
			340	+	NotifyVarRef = purego.NewCallback(fcb)
			341	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			342	+	}
			343	+	}
			344	+
			345	+	xMainContextInvokeFull(x.GoPointer(), PriorityVar, FunctionVarRef, DataVar, NotifyVarRef)
301			346
302		}	347		}
303			348

@@ -530,7 +575,22 @@ var xMainContextSetPollFunc func(uintptr, uintptr)
530		// loop with an external event loop.	575		// loop with an external event loop.
531		func (x MainContext) SetPollFunc(FuncVar PollFunc) {	576		func (x MainContext) SetPollFunc(FuncVar PollFunc) {
532			577
533	-	xMainContextSetPollFunc(x.GoPointer(), NewCallback(FuncVar))	578	+	var FuncVarRef uintptr
			579	+	if FuncVar != nil {
			580	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			581	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			582	+	FuncVarRef = cbRefPtr
			583	+	} else {
			584	+	fcb := func(arg0 *PollFD, arg1 uint, arg2 int) int {
			585	+	cbFn := *FuncVar
			586	+	return cbFn(arg0, arg1, arg2)
			587	+	}
			588	+	FuncVarRef = purego.NewCallback(fcb)
			589	+	SaveCallback(FuncVarPtr, FuncVarRef)
			590	+	}
			591	+	}
			592	+
			593	+	xMainContextSetPollFunc(x.GoPointer(), FuncVarRef)
534			594
535		}	595		}
536			596

@@ -1196,7 +1256,37 @@ var xSourceSetCallback func(uintptr, uintptr, uintptr, uintptr)
1196		// of also unsetting the callback.	1256		// of also unsetting the callback.
1197		func (x Source) SetCallback(FuncVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {	1257		func (x Source) SetCallback(FuncVar SourceFunc, DataVar uintptr, NotifyVar *DestroyNotify) {
1198			1258
1199	-	xSourceSetCallback(x.GoPointer(), NewCallback(FuncVar), DataVar, NewCallbackNullable(NotifyVar))	1259	+	var FuncVarRef uintptr
			1260	+	if FuncVar != nil {
			1261	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			1262	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			1263	+	FuncVarRef = cbRefPtr
			1264	+	} else {
			1265	+	fcb := func(arg0 uintptr) bool {
			1266	+	cbFn := *FuncVar
			1267	+	return cbFn(arg0)
			1268	+	}
			1269	+	FuncVarRef = purego.NewCallback(fcb)
			1270	+	SaveCallback(FuncVarPtr, FuncVarRef)
			1271	+	}
			1272	+	}
			1273	+
			1274	+	var NotifyVarRef uintptr
			1275	+	if NotifyVar != nil {
			1276	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1277	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			1278	+	NotifyVarRef = cbRefPtr
			1279	+	} else {
			1280	+	fcb := func(arg0 uintptr) {
			1281	+	cbFn := *NotifyVar
			1282	+	cbFn(arg0)
			1283	+	}
			1284	+	NotifyVarRef = purego.NewCallback(fcb)
			1285	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			1286	+	}
			1287	+	}
			1288	+
			1289	+	xSourceSetCallback(x.GoPointer(), FuncVarRef, DataVar, NotifyVarRef)
1200			1290
1201		}	1291		}
1202			1292

@@ -1257,7 +1347,22 @@ var xSourceSetDisposeFunction func(uintptr, uintptr)
1257		// This should only ever be called from [struct@GLib.Source] implementations.	1347		// This should only ever be called from [struct@GLib.Source] implementations.
1258		func (x Source) SetDisposeFunction(DisposeVar SourceDisposeFunc) {	1348		func (x Source) SetDisposeFunction(DisposeVar SourceDisposeFunc) {
1259			1349
1260	-	xSourceSetDisposeFunction(x.GoPointer(), NewCallback(DisposeVar))	1350	+	var DisposeVarRef uintptr
			1351	+	if DisposeVar != nil {
			1352	+	DisposeVarPtr := uintptr(unsafe.Pointer(DisposeVar))
			1353	+	if cbRefPtr, ok := GetCallback(DisposeVarPtr); ok {
			1354	+	DisposeVarRef = cbRefPtr
			1355	+	} else {
			1356	+	fcb := func(arg0 *Source) {
			1357	+	cbFn := *DisposeVar
			1358	+	cbFn(arg0)
			1359	+	}
			1360	+	DisposeVarRef = purego.NewCallback(fcb)
			1361	+	SaveCallback(DisposeVarPtr, DisposeVarRef)
			1362	+	}
			1363	+	}
			1364	+
			1365	+	xSourceSetDisposeFunction(x.GoPointer(), DisposeVarRef)
1261			1366
1262		}	1367		}
1263			1368

@@ -1595,7 +1700,22 @@ var xChildWatchAdd func(Pid, uintptr, uintptr) uint
1595		// need greater control.	1700		// need greater control.
1596		func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {	1701		func ChildWatchAdd(PidVar Pid, FunctionVar *ChildWatchFunc, DataVar uintptr) uint {
1597			1702
1598	-	cret := xChildWatchAdd(PidVar, NewCallback(FunctionVar), DataVar)	1703	+	var FunctionVarRef uintptr
			1704	+	if FunctionVar != nil {
			1705	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			1706	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			1707	+	FunctionVarRef = cbRefPtr
			1708	+	} else {
			1709	+	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
			1710	+	cbFn := *FunctionVar
			1711	+	cbFn(arg0, arg1, arg2)
			1712	+	}
			1713	+	FunctionVarRef = purego.NewCallback(fcb)
			1714	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			1715	+	}
			1716	+	}
			1717	+
			1718	+	cret := xChildWatchAdd(PidVar, FunctionVarRef, DataVar)
1599		return cret	1719		return cret
1600		}	1720		}
1601			1721

@@ -1628,7 +1748,37 @@ var xChildWatchAddFull func(int, Pid, uintptr, uintptr, uintptr) uint
1628		// need greater control.	1748		// need greater control.
1629		func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1749		func ChildWatchAddFull(PriorityVar int, PidVar Pid, FunctionVar ChildWatchFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1630			1750
1631	-	cret := xChildWatchAddFull(PriorityVar, PidVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))	1751	+	var FunctionVarRef uintptr
			1752	+	if FunctionVar != nil {
			1753	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			1754	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			1755	+	FunctionVarRef = cbRefPtr
			1756	+	} else {
			1757	+	fcb := func(arg0 Pid, arg1 int, arg2 uintptr) {
			1758	+	cbFn := *FunctionVar
			1759	+	cbFn(arg0, arg1, arg2)
			1760	+	}
			1761	+	FunctionVarRef = purego.NewCallback(fcb)
			1762	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			1763	+	}
			1764	+	}
			1765	+
			1766	+	var NotifyVarRef uintptr
			1767	+	if NotifyVar != nil {
			1768	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1769	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			1770	+	NotifyVarRef = cbRefPtr
			1771	+	} else {
			1772	+	fcb := func(arg0 uintptr) {
			1773	+	cbFn := *NotifyVar
			1774	+	cbFn(arg0)
			1775	+	}
			1776	+	NotifyVarRef = purego.NewCallback(fcb)
			1777	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			1778	+	}
			1779	+	}
			1780	+
			1781	+	cret := xChildWatchAddFull(PriorityVar, PidVar, FunctionVarRef, DataVar, NotifyVarRef)
1632		return cret	1782		return cret
1633		}	1783		}
1634			1784

@@ -1694,7 +1844,22 @@ var xClearHandleId func(uint, uintptr)
1694		// pointer casts.	1844		// pointer casts.
1695		func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {	1845		func ClearHandleId(TagPtrVar uint, ClearFuncVar *ClearHandleFunc) {
1696			1846
1697	-	xClearHandleId(TagPtrVar, NewCallback(ClearFuncVar))	1847	+	var ClearFuncVarRef uintptr
			1848	+	if ClearFuncVar != nil {
			1849	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
			1850	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
			1851	+	ClearFuncVarRef = cbRefPtr
			1852	+	} else {
			1853	+	fcb := func(arg0 uint) {
			1854	+	cbFn := *ClearFuncVar
			1855	+	cbFn(arg0)
			1856	+	}
			1857	+	ClearFuncVarRef = purego.NewCallback(fcb)
			1858	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
			1859	+	}
			1860	+	}
			1861	+
			1862	+	xClearHandleId(TagPtrVar, ClearFuncVarRef)
1698			1863
1699		}	1864		}
1700			1865

@@ -1767,7 +1932,22 @@ var xIdleAdd func(uintptr, uintptr) uint
1767		// need greater control or to use a custom main context.	1932		// need greater control or to use a custom main context.
1768		func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {	1933		func IdleAdd(FunctionVar *SourceFunc, DataVar uintptr) uint {
1769			1934
1770	-	cret := xIdleAdd(NewCallback(FunctionVar), DataVar)	1935	+	var FunctionVarRef uintptr
			1936	+	if FunctionVar != nil {
			1937	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			1938	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			1939	+	FunctionVarRef = cbRefPtr
			1940	+	} else {
			1941	+	fcb := func(arg0 uintptr) bool {
			1942	+	cbFn := *FunctionVar
			1943	+	return cbFn(arg0)
			1944	+	}
			1945	+	FunctionVarRef = purego.NewCallback(fcb)
			1946	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			1947	+	}
			1948	+	}
			1949	+
			1950	+	cret := xIdleAdd(FunctionVarRef, DataVar)
1771		return cret	1951		return cret
1772		}	1952		}
1773			1953

@@ -1789,7 +1969,37 @@ var xIdleAddFull func(int, uintptr, uintptr, uintptr) uint
1789		// need greater control or to use a custom main context.	1969		// need greater control or to use a custom main context.
1790		func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	1970		func IdleAddFull(PriorityVar int, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
1791			1971
1792	-	cret := xIdleAddFull(PriorityVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))	1972	+	var FunctionVarRef uintptr
			1973	+	if FunctionVar != nil {
			1974	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			1975	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			1976	+	FunctionVarRef = cbRefPtr
			1977	+	} else {
			1978	+	fcb := func(arg0 uintptr) bool {
			1979	+	cbFn := *FunctionVar
			1980	+	return cbFn(arg0)
			1981	+	}
			1982	+	FunctionVarRef = purego.NewCallback(fcb)
			1983	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			1984	+	}
			1985	+	}
			1986	+
			1987	+	var NotifyVarRef uintptr
			1988	+	if NotifyVar != nil {
			1989	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1990	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			1991	+	NotifyVarRef = cbRefPtr
			1992	+	} else {
			1993	+	fcb := func(arg0 uintptr) {
			1994	+	cbFn := *NotifyVar
			1995	+	cbFn(arg0)
			1996	+	}
			1997	+	NotifyVarRef = purego.NewCallback(fcb)
			1998	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			1999	+	}
			2000	+	}
			2001	+
			2002	+	cret := xIdleAddFull(PriorityVar, FunctionVarRef, DataVar, NotifyVarRef)
1793		return cret	2003		return cret
1794		}	2004		}
1795			2005

@@ -1807,7 +2017,22 @@ var xIdleAddOnce func(uintptr, uintptr) uint
1807		// This function otherwise behaves like [func@GLib.idle_add].	2017		// This function otherwise behaves like [func@GLib.idle_add].
1808		func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	2018		func IdleAddOnce(FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
1809			2019
1810	-	cret := xIdleAddOnce(NewCallback(FunctionVar), DataVar)	2020	+	var FunctionVarRef uintptr
			2021	+	if FunctionVar != nil {
			2022	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2023	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2024	+	FunctionVarRef = cbRefPtr
			2025	+	} else {
			2026	+	fcb := func(arg0 uintptr) {
			2027	+	cbFn := *FunctionVar
			2028	+	cbFn(arg0)
			2029	+	}
			2030	+	FunctionVarRef = purego.NewCallback(fcb)
			2031	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2032	+	}
			2033	+	}
			2034	+
			2035	+	cret := xIdleAddOnce(FunctionVarRef, DataVar)
1811		return cret	2036		return cret
1812		}	2037		}
1813			2038

@@ -2130,7 +2355,22 @@ var xTimeoutAdd func(uint, uintptr, uintptr) uint
2130		// time. See [func@GLib.get_monotonic_time].	2355		// time. See [func@GLib.get_monotonic_time].
2131		func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {	2356		func TimeoutAdd(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2132			2357
2133	-	cret := xTimeoutAdd(IntervalVar, NewCallback(FunctionVar), DataVar)	2358	+	var FunctionVarRef uintptr
			2359	+	if FunctionVar != nil {
			2360	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2361	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2362	+	FunctionVarRef = cbRefPtr
			2363	+	} else {
			2364	+	fcb := func(arg0 uintptr) bool {
			2365	+	cbFn := *FunctionVar
			2366	+	return cbFn(arg0)
			2367	+	}
			2368	+	FunctionVarRef = purego.NewCallback(fcb)
			2369	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2370	+	}
			2371	+	}
			2372	+
			2373	+	cret := xTimeoutAdd(IntervalVar, FunctionVarRef, DataVar)
2134		return cret	2374		return cret
2135		}	2375		}
2136			2376

@@ -2166,7 +2406,37 @@ var xTimeoutAddFull func(int, uint, uintptr, uintptr, uintptr) uint
2166		// See [func@GLib.get_monotonic_time].	2406		// See [func@GLib.get_monotonic_time].
2167		func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	2407		func TimeoutAddFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2168			2408
2169	-	cret := xTimeoutAddFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))	2409	+	var FunctionVarRef uintptr
			2410	+	if FunctionVar != nil {
			2411	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2412	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2413	+	FunctionVarRef = cbRefPtr
			2414	+	} else {
			2415	+	fcb := func(arg0 uintptr) bool {
			2416	+	cbFn := *FunctionVar
			2417	+	return cbFn(arg0)
			2418	+	}
			2419	+	FunctionVarRef = purego.NewCallback(fcb)
			2420	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2421	+	}
			2422	+	}
			2423	+
			2424	+	var NotifyVarRef uintptr
			2425	+	if NotifyVar != nil {
			2426	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			2427	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			2428	+	NotifyVarRef = cbRefPtr
			2429	+	} else {
			2430	+	fcb := func(arg0 uintptr) {
			2431	+	cbFn := *NotifyVar
			2432	+	cbFn(arg0)
			2433	+	}
			2434	+	NotifyVarRef = purego.NewCallback(fcb)
			2435	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			2436	+	}
			2437	+	}
			2438	+
			2439	+	cret := xTimeoutAddFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)
2170		return cret	2440		return cret
2171		}	2441		}
2172			2442

@@ -2181,7 +2451,22 @@ var xTimeoutAddOnce func(uint, uintptr, uintptr) uint
2181		// This function otherwise behaves like [func@GLib.timeout_add].	2451		// This function otherwise behaves like [func@GLib.timeout_add].
2182		func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	2452		func TimeoutAddOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2183			2453
2184	-	cret := xTimeoutAddOnce(IntervalVar, NewCallback(FunctionVar), DataVar)	2454	+	var FunctionVarRef uintptr
			2455	+	if FunctionVar != nil {
			2456	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2457	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2458	+	FunctionVarRef = cbRefPtr
			2459	+	} else {
			2460	+	fcb := func(arg0 uintptr) {
			2461	+	cbFn := *FunctionVar
			2462	+	cbFn(arg0)
			2463	+	}
			2464	+	FunctionVarRef = purego.NewCallback(fcb)
			2465	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2466	+	}
			2467	+	}
			2468	+
			2469	+	cret := xTimeoutAddOnce(IntervalVar, FunctionVarRef, DataVar)
2185		return cret	2470		return cret
2186		}	2471		}
2187			2472

@@ -2212,7 +2497,22 @@ var xTimeoutAddSeconds func(uint, uintptr, uintptr) uint
2212		// time. See [func@GLib.get_monotonic_time].	2497		// time. See [func@GLib.get_monotonic_time].
2213		func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {	2498		func TimeoutAddSeconds(IntervalVar uint, FunctionVar *SourceFunc, DataVar uintptr) uint {
2214			2499
2215	-	cret := xTimeoutAddSeconds(IntervalVar, NewCallback(FunctionVar), DataVar)	2500	+	var FunctionVarRef uintptr
			2501	+	if FunctionVar != nil {
			2502	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2503	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2504	+	FunctionVarRef = cbRefPtr
			2505	+	} else {
			2506	+	fcb := func(arg0 uintptr) bool {
			2507	+	cbFn := *FunctionVar
			2508	+	return cbFn(arg0)
			2509	+	}
			2510	+	FunctionVarRef = purego.NewCallback(fcb)
			2511	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2512	+	}
			2513	+	}
			2514	+
			2515	+	cret := xTimeoutAddSeconds(IntervalVar, FunctionVarRef, DataVar)
2216		return cret	2516		return cret
2217		}	2517		}
2218			2518

@@ -2260,7 +2560,37 @@ var xTimeoutAddSecondsFull func(int, uint, uintptr, uintptr, uintptr) uint
2260		// time. See [func@GLib.get_monotonic_time].	2560		// time. See [func@GLib.get_monotonic_time].
2261		func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {	2561		func TimeoutAddSecondsFull(PriorityVar int, IntervalVar uint, FunctionVar SourceFunc, DataVar uintptr, NotifyVar DestroyNotify) uint {
2262			2562
2263	-	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, NewCallback(FunctionVar), DataVar, NewCallbackNullable(NotifyVar))	2563	+	var FunctionVarRef uintptr
			2564	+	if FunctionVar != nil {
			2565	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2566	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2567	+	FunctionVarRef = cbRefPtr
			2568	+	} else {
			2569	+	fcb := func(arg0 uintptr) bool {
			2570	+	cbFn := *FunctionVar
			2571	+	return cbFn(arg0)
			2572	+	}
			2573	+	FunctionVarRef = purego.NewCallback(fcb)
			2574	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2575	+	}
			2576	+	}
			2577	+
			2578	+	var NotifyVarRef uintptr
			2579	+	if NotifyVar != nil {
			2580	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			2581	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			2582	+	NotifyVarRef = cbRefPtr
			2583	+	} else {
			2584	+	fcb := func(arg0 uintptr) {
			2585	+	cbFn := *NotifyVar
			2586	+	cbFn(arg0)
			2587	+	}
			2588	+	NotifyVarRef = purego.NewCallback(fcb)
			2589	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			2590	+	}
			2591	+	}
			2592	+
			2593	+	cret := xTimeoutAddSecondsFull(PriorityVar, IntervalVar, FunctionVarRef, DataVar, NotifyVarRef)
2264		return cret	2594		return cret
2265		}	2595		}
2266			2596

@@ -2270,7 +2600,22 @@ var xTimeoutAddSecondsOnce func(uint, uintptr, uintptr) uint
2270		// seconds.	2600		// seconds.
2271		func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {	2601		func TimeoutAddSecondsOnce(IntervalVar uint, FunctionVar *SourceOnceFunc, DataVar uintptr) uint {
2272			2602
2273	-	cret := xTimeoutAddSecondsOnce(IntervalVar, NewCallback(FunctionVar), DataVar)	2603	+	var FunctionVarRef uintptr
			2604	+	if FunctionVar != nil {
			2605	+	FunctionVarPtr := uintptr(unsafe.Pointer(FunctionVar))
			2606	+	if cbRefPtr, ok := GetCallback(FunctionVarPtr); ok {
			2607	+	FunctionVarRef = cbRefPtr
			2608	+	} else {
			2609	+	fcb := func(arg0 uintptr) {
			2610	+	cbFn := *FunctionVar
			2611	+	cbFn(arg0)
			2612	+	}
			2613	+	FunctionVarRef = purego.NewCallback(fcb)
			2614	+	SaveCallback(FunctionVarPtr, FunctionVarRef)
			2615	+	}
			2616	+	}
			2617	+
			2618	+	cret := xTimeoutAddSecondsOnce(IntervalVar, FunctionVarRef, DataVar)
2274		return cret	2619		return cret
2275		}	2620		}
2276			2621

M v4/glib/gmarkup.go +16 -1


@@ -38,7 +38,22 @@ var xNewMarkupParseContext func(*MarkupParser, MarkupParseFlags, uintptr, uintpt
38		// free it and create a new parse context).	38		// free it and create a new parse context).
39		func NewMarkupParseContext(ParserVar MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar DestroyNotify) *MarkupParseContext {	39		func NewMarkupParseContext(ParserVar MarkupParser, FlagsVar MarkupParseFlags, UserDataVar uintptr, UserDataDnotifyVar DestroyNotify) *MarkupParseContext {
40			40
41	-	cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, NewCallback(UserDataDnotifyVar))	41	+	var UserDataDnotifyVarRef uintptr
			42	+	if UserDataDnotifyVar != nil {
			43	+	UserDataDnotifyVarPtr := uintptr(unsafe.Pointer(UserDataDnotifyVar))
			44	+	if cbRefPtr, ok := GetCallback(UserDataDnotifyVarPtr); ok {
			45	+	UserDataDnotifyVarRef = cbRefPtr
			46	+	} else {
			47	+	fcb := func(arg0 uintptr) {
			48	+	cbFn := *UserDataDnotifyVar
			49	+	cbFn(arg0)
			50	+	}
			51	+	UserDataDnotifyVarRef = purego.NewCallback(fcb)
			52	+	SaveCallback(UserDataDnotifyVarPtr, UserDataDnotifyVarRef)
			53	+	}
			54	+	}
			55	+
			56	+	cret := xNewMarkupParseContext(ParserVar, FlagsVar, UserDataVar, UserDataDnotifyVarRef)
42		return cret	57		return cret
43		}	58		}
44			59

M v4/glib/gmem.go +16 -1


@@ -279,7 +279,22 @@ var xClearPointer func(uintptr, uintptr)
279		// ```	279		// ```
280		func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {	280		func ClearPointer(PpVar uintptr, DestroyVar *DestroyNotify) {
281			281
282	-	xClearPointer(PpVar, NewCallback(DestroyVar))	282	+	var DestroyVarRef uintptr
			283	+	if DestroyVar != nil {
			284	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			285	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
			286	+	DestroyVarRef = cbRefPtr
			287	+	} else {
			288	+	fcb := func(arg0 uintptr) {
			289	+	cbFn := *DestroyVar
			290	+	cbFn(arg0)
			291	+	}
			292	+	DestroyVarRef = purego.NewCallback(fcb)
			293	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
			294	+	}
			295	+	}
			296	+
			297	+	xClearPointer(PpVar, DestroyVarRef)
283			298
284		}	299		}
285			300

M v4/glib/gmessages.go +154 -34

 }
-var xLog func(string, LogLevelFlags, string, ...interface{})
+var xLog func(uintptr, LogLevelFlags, string, ...interface{})
 // Logs an error or debugging message.
 //
 //
 // If [structured logging is enabled](logging.html#using-structured-logging) this will
 // output via the structured log writer function (see [func@GLib.log_set_writer_func]).
-func Log(LogDomainVar string, LogLevelVar LogLevelFlags, FormatVar string, varArgs ...interface{}) {
+func Log(LogDomainVar *string, LogLevelVar LogLevelFlags, FormatVar string, varArgs ...interface{}) {
-	xLog(LogDomainVar, LogLevelVar, FormatVar, varArgs...)
+	xLog(core.NullableStringToPtr(LogDomainVar), LogLevelVar, FormatVar, varArgs...)
 }
-var xLogDefaultHandler func(string, LogLevelFlags, string, uintptr)
+var xLogDefaultHandler func(uintptr, LogLevelFlags, uintptr, uintptr)
 // The default log handler set up by GLib; [func@GLib.log_set_default_handler]
 // allows to install an alternate default log handler.
 //
 // This has no effect if structured logging is enabled; see
 // [Using Structured Logging](logging.html#using-structured-logging).
-func LogDefaultHandler(LogDomainVar string, LogLevelVar LogLevelFlags, MessageVar string, UnusedDataVar uintptr) {
+func LogDefaultHandler(LogDomainVar *string, LogLevelVar LogLevelFlags, MessageVar *string, UnusedDataVar uintptr) {
-	xLogDefaultHandler(LogDomainVar, LogLevelVar, MessageVar, UnusedDataVar)
+	xLogDefaultHandler(core.NullableStringToPtr(LogDomainVar), LogLevelVar, core.NullableStringToPtr(MessageVar), UnusedDataVar)
 }
 // [Using Structured Logging](logging.html#using-structured-logging).
 func LogSetDefaultHandler(LogFuncVar *LogFunc, UserDataVar uintptr) uintptr {
-	cret := xLogSetDefaultHandler(NewCallback(LogFuncVar), UserDataVar)
+	var LogFuncVarRef uintptr
+	if LogFuncVar != nil {
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+			LogFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
+		}
+	}
+	cret := xLogSetDefaultHandler(LogFuncVarRef, UserDataVar)
 	return cret
 }
 	return cret
 }
-var xLogSetHandler func(string, LogLevelFlags, uintptr, uintptr) uint
+var xLogSetHandler func(uintptr, LogLevelFlags, uintptr, uintptr) uint
 // Sets the log handler for a domain and a set of log levels.
 //
 //	| G_LOG_FLAG_RECURSION, my_log_handler, NULL);
 //
 // ```
-func LogSetHandler(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
+func LogSetHandler(LogDomainVar *string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr) uint {
+	var LogFuncVarRef uintptr
+	if LogFuncVar != nil {
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+			LogFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
+		}
+	}
-	cret := xLogSetHandler(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar)
+	cret := xLogSetHandler(core.NullableStringToPtr(LogDomainVar), LogLevelsVar, LogFuncVarRef, UserDataVar)
 	return cret
 }
-var xLogSetHandlerFull func(string, LogLevelFlags, uintptr, uintptr, uintptr) uint
+var xLogSetHandlerFull func(uintptr, LogLevelFlags, uintptr, uintptr, uintptr) uint
 // Like [func@GLib.log_set_handler], but takes a destroy notify for the @user_data.
 //
 //
 // The `log_domain` parameter can be set to `NULL` or an empty string to use the default
 // application domain.
-func LogSetHandlerFull(LogDomainVar string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {
+func LogSetHandlerFull(LogDomainVar *string, LogLevelsVar LogLevelFlags, LogFuncVar *LogFunc, UserDataVar uintptr, DestroyVar *DestroyNotify) uint {
+	var LogFuncVarRef uintptr
+	if LogFuncVar != nil {
+		LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
+		if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
+			LogFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) {
+				cbFn := *LogFuncVar
+				cbFn(arg0, arg1, arg2, arg3)
+			}
+			LogFuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(LogFuncVarPtr, LogFuncVarRef)
+		}
+	}
-	cret := xLogSetHandlerFull(LogDomainVar, LogLevelsVar, NewCallback(LogFuncVar), UserDataVar, NewCallback(DestroyVar))
+	var DestroyVarRef uintptr
+	if DestroyVar != nil {
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
+		if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
+			DestroyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			SaveCallback(DestroyVarPtr, DestroyVarRef)
+		}
+	}
+	cret := xLogSetHandlerFull(core.NullableStringToPtr(LogDomainVar), LogLevelsVar, LogFuncVarRef, UserDataVar, DestroyVarRef)
 	return cret
 }
 // There can only be one writer function. It is an error to set more than one.
 func LogSetWriterFunc(FuncVar *LogWriterFunc, UserDataVar uintptr, UserDataFreeVar *DestroyNotify) {
-	xLogSetWriterFunc(NewCallback(FuncVar), UserDataVar, NewCallback(UserDataFreeVar))
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 LogLevelFlags, arg1 []LogField, arg2 uint, arg3 uintptr) LogWriterOutput {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2, arg3)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	var UserDataFreeVarRef uintptr
+	if UserDataFreeVar != nil {
+		UserDataFreeVarPtr := uintptr(unsafe.Pointer(UserDataFreeVar))
+		if cbRefPtr, ok := GetCallback(UserDataFreeVarPtr); ok {
+			UserDataFreeVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *UserDataFreeVar
+				cbFn(arg0)
+			}
+			UserDataFreeVarRef = purego.NewCallback(fcb)
+			SaveCallback(UserDataFreeVarPtr, UserDataFreeVarRef)
+		}
+	}
+	xLogSetWriterFunc(FuncVarRef, UserDataVar, UserDataFreeVarRef)
 }
 }
-var xLogVariant func(string, LogLevelFlags, *Variant)
+var xLogVariant func(uintptr, LogLevelFlags, *Variant)
 // Log a message with structured data, accepting the data within a [type@GLib.Variant].
 //
 // [method@GLib.Variant.print] will be used to convert the value into a string.
 //
 // For more details on its usage and about the parameters, see [func@GLib.log_structured].
-func LogVariant(LogDomainVar string, LogLevelVar LogLevelFlags, FieldsVar *Variant) {
+func LogVariant(LogDomainVar *string, LogLevelVar LogLevelFlags, FieldsVar *Variant) {
-	xLogVariant(LogDomainVar, LogLevelVar, FieldsVar)
+	xLogVariant(core.NullableStringToPtr(LogDomainVar), LogLevelVar, FieldsVar)
 }
 	return cret
 }
-var xLogWriterDefaultSetDebugDomains func(string)
+var xLogWriterDefaultSetDebugDomains func(uintptr)
 // Reset the list of domains to be logged, that might be initially set by the
 // `G_MESSAGES_DEBUG` or `DEBUG_INVOCATION` environment variables.
 //
 // This function is thread-safe.
-func LogWriterDefaultSetDebugDomains(DomainsVar string) {
+func LogWriterDefaultSetDebugDomains(DomainsVar *string) {
-	xLogWriterDefaultSetDebugDomains(DomainsVar)
+	xLogWriterDefaultSetDebugDomains(core.NullableStringToPtr(DomainsVar))
 }
 }
-var xLogWriterDefaultWouldDrop func(LogLevelFlags, string) bool
+var xLogWriterDefaultWouldDrop func(LogLevelFlags, uintptr) bool
 // Check whether [func@GLib.log_writer_default] and [func@GLib.log_default_handler] would
 // ignore a message with the given domain and level.
 //	}
 //
 // ```
-func LogWriterDefaultWouldDrop(LogLevelVar LogLevelFlags, LogDomainVar string) bool {
+func LogWriterDefaultWouldDrop(LogLevelVar LogLevelFlags, LogDomainVar *string) bool {
-	cret := xLogWriterDefaultWouldDrop(LogLevelVar, LogDomainVar)
+	cret := xLogWriterDefaultWouldDrop(LogLevelVar, core.NullableStringToPtr(LogDomainVar))
 	return cret
 }
 	return cret
 }
-var xLogv func(string, LogLevelFlags, string, []interface{})
+var xLogv func(uintptr, LogLevelFlags, string, []interface{})
 // Logs an error or debugging message.
 //
 //
 // The `log_domain` parameter can be set to `NULL` or an empty string to use the default
 // application domain.
-func Logv(LogDomainVar string, LogLevelVar LogLevelFlags, FormatVar string, ArgsVar []interface{}) {
+func Logv(LogDomainVar *string, LogLevelVar LogLevelFlags, FormatVar string, ArgsVar []interface{}) {
-	xLogv(LogDomainVar, LogLevelVar, FormatVar, ArgsVar)
+	xLogv(core.NullableStringToPtr(LogDomainVar), LogLevelVar, FormatVar, ArgsVar)
 }
 	return cret
 }
-var xReturnIfFailWarning func(string, string, string)
+var xReturnIfFailWarning func(uintptr, string, uintptr)
 // Internal function used to print messages from the public [func@GLib.return_if_fail]
 // and [func@GLib.return_val_if_fail] macros.
-func ReturnIfFailWarning(LogDomainVar string, PrettyFunctionVar string, ExpressionVar string) {
+func ReturnIfFailWarning(LogDomainVar *string, PrettyFunctionVar string, ExpressionVar *string) {
-	xReturnIfFailWarning(LogDomainVar, PrettyFunctionVar, ExpressionVar)
+	xReturnIfFailWarning(core.NullableStringToPtr(LogDomainVar), PrettyFunctionVar, core.NullableStringToPtr(ExpressionVar))
 }
 // in all platforms. Before GLib 2.76, this was `NULL`.
 func SetPrintHandler(FuncVar *PrintFunc) uintptr {
-	cret := xSetPrintHandler(NewCallbackNullable(FuncVar))
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string) {
+				cbFn := *FuncVar
+				cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	cret := xSetPrintHandler(FuncVarRef)
 	return cret
 }
 // Before GLib 2.76, this was `NULL`.
 func SetPrinterrHandler(FuncVar *PrintFunc) uintptr {
-	cret := xSetPrinterrHandler(NewCallbackNullable(FuncVar))
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string) {
+				cbFn := *FuncVar
+				cbFn(arg0)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	cret := xSetPrinterrHandler(FuncVarRef)
 	return cret
 }
-var xWarnMessage func(string, string, int, string, string)
+var xWarnMessage func(uintptr, string, int, string, uintptr)
 // Internal function used to print messages from the public [func@GLib.warn_if_reached]
 // and [func@GLib.warn_if_fail] macros.
-func WarnMessage(DomainVar string, FileVar string, LineVar int, FuncVar string, WarnexprVar string) {
+func WarnMessage(DomainVar *string, FileVar string, LineVar int, FuncVar string, WarnexprVar *string) {
-	xWarnMessage(DomainVar, FileVar, LineVar, FuncVar, WarnexprVar)
+	xWarnMessage(core.NullableStringToPtr(DomainVar), FileVar, LineVar, FuncVar, core.NullableStringToPtr(WarnexprVar))
 }

M v4/glib/gnode.go +48 -3


@@ -67,7 +67,22 @@ var xNodeChildrenForeach func(uintptr, TraverseFlags, uintptr, uintptr)
67		// that would modify the structure of the tree.	67		// that would modify the structure of the tree.
68		func (x Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar NodeForeachFunc, DataVar uintptr) {	68		func (x Node) ChildrenForeach(FlagsVar TraverseFlags, FuncVar NodeForeachFunc, DataVar uintptr) {
69			69
70	-	xNodeChildrenForeach(x.GoPointer(), FlagsVar, NewCallback(FuncVar), DataVar)	70	+	var FuncVarRef uintptr
			71	+	if FuncVar != nil {
			72	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			73	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			74	+	FuncVarRef = cbRefPtr
			75	+	} else {
			76	+	fcb := func(arg0 *Node, arg1 uintptr) {
			77	+	cbFn := *FuncVar
			78	+	cbFn(arg0, arg1)
			79	+	}
			80	+	FuncVarRef = purego.NewCallback(fcb)
			81	+	SaveCallback(FuncVarPtr, FuncVarRef)
			82	+	}
			83	+	}
			84	+
			85	+	xNodeChildrenForeach(x.GoPointer(), FlagsVar, FuncVarRef, DataVar)
71			86
72		}	87		}
73			88

@@ -86,7 +101,22 @@ var xNodeCopyDeep func(uintptr, uintptr, uintptr) *Node
86		// Recursively copies a #GNode and its data.	101		// Recursively copies a #GNode and its data.
87		func (x Node) CopyDeep(CopyFuncVar CopyFunc, DataVar uintptr) *Node {	102		func (x Node) CopyDeep(CopyFuncVar CopyFunc, DataVar uintptr) *Node {
88			103
89	-	cret := xNodeCopyDeep(x.GoPointer(), NewCallback(CopyFuncVar), DataVar)	104	+	var CopyFuncVarRef uintptr
			105	+	if CopyFuncVar != nil {
			106	+	CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
			107	+	if cbRefPtr, ok := GetCallback(CopyFuncVarPtr); ok {
			108	+	CopyFuncVarRef = cbRefPtr
			109	+	} else {
			110	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			111	+	cbFn := *CopyFuncVar
			112	+	return cbFn(arg0, arg1)
			113	+	}
			114	+	CopyFuncVarRef = purego.NewCallback(fcb)
			115	+	SaveCallback(CopyFuncVarPtr, CopyFuncVarRef)
			116	+	}
			117	+	}
			118	+
			119	+	cret := xNodeCopyDeep(x.GoPointer(), CopyFuncVarRef, DataVar)
90		return cret	120		return cret
91		}	121		}
92			122

@@ -275,7 +305,22 @@ var xNodeTraverse func(uintptr, TraverseType, TraverseFlags, int, uintptr, uintp
275		// @func must not do anything that would modify the structure of the tree.	305		// @func must not do anything that would modify the structure of the tree.
276		func (x Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar NodeTraverseFunc, DataVar uintptr) {	306		func (x Node) Traverse(OrderVar TraverseType, FlagsVar TraverseFlags, MaxDepthVar int, FuncVar NodeTraverseFunc, DataVar uintptr) {
277			307
278	-	xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, NewCallback(FuncVar), DataVar)	308	+	var FuncVarRef uintptr
			309	+	if FuncVar != nil {
			310	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			311	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			312	+	FuncVarRef = cbRefPtr
			313	+	} else {
			314	+	fcb := func(arg0 *Node, arg1 uintptr) bool {
			315	+	cbFn := *FuncVar
			316	+	return cbFn(arg0, arg1)
			317	+	}
			318	+	FuncVarRef = purego.NewCallback(fcb)
			319	+	SaveCallback(FuncVarPtr, FuncVarRef)
			320	+	}
			321	+	}
			322	+
			323	+	xNodeTraverse(x.GoPointer(), OrderVar, FlagsVar, MaxDepthVar, FuncVarRef, DataVar)
279			324
280		}	325		}
281			326

M v4/glib/goption.go +134 -14


@@ -42,13 +42,13 @@ func (x OptionContext) AddGroup(GroupVar OptionGroup) {
42			42
43		}	43		}
44			44
45	-	var xOptionContextAddMainEntries func(uintptr, []OptionEntry, string)	45	+	var xOptionContextAddMainEntries func(uintptr, []OptionEntry, uintptr)
46			46
47		// A convenience function which creates a main group if it doesn't	47		// A convenience function which creates a main group if it doesn't
48		// exist, adds the @entries to it and sets the translation domain.	48		// exist, adds the @entries to it and sets the translation domain.
49	-	func (x *OptionContext) AddMainEntries(EntriesVar []OptionEntry, TranslationDomainVar string) {	49	+	func (x OptionContext) AddMainEntries(EntriesVar []OptionEntry, TranslationDomainVar string) {
50			50
51	-	xOptionContextAddMainEntries(x.GoPointer(), EntriesVar, TranslationDomainVar)	51	+	xOptionContextAddMainEntries(x.GoPointer(), EntriesVar, core.NullableStringToPtr(TranslationDomainVar))
52			52
53		}	53		}
54			54

@@ -201,16 +201,16 @@ func (x *OptionContext) ParseStrv(ArgumentsVar []string) (bool, error) {
201			201
202		}	202		}
203			203
204	-	var xOptionContextSetDescription func(uintptr, string)	204	+	var xOptionContextSetDescription func(uintptr, uintptr)
205			205
206		// Adds a string to be displayed in `--help` output after the list	206		// Adds a string to be displayed in `--help` output after the list
207		// of options. This text often includes a bug reporting address.	207		// of options. This text often includes a bug reporting address.
208		//	208		//
209		// Note that the summary is translated (see	209		// Note that the summary is translated (see
210		// g_option_context_set_translate_func()).	210		// g_option_context_set_translate_func()).
211	-	func (x *OptionContext) SetDescription(DescriptionVar string) {	211	+	func (x OptionContext) SetDescription(DescriptionVar string) {
212			212
213	-	xOptionContextSetDescription(x.GoPointer(), DescriptionVar)	213	+	xOptionContextSetDescription(x.GoPointer(), core.NullableStringToPtr(DescriptionVar))
214			214
215		}	215		}
216			216

@@ -285,7 +285,7 @@ func (x *OptionContext) SetStrictPosix(StrictPosixVar bool) {
285			285
286		}	286		}
287			287
288	-	var xOptionContextSetSummary func(uintptr, string)	288	+	var xOptionContextSetSummary func(uintptr, uintptr)
289			289
290		// Adds a string to be displayed in `--help` output before the list	290		// Adds a string to be displayed in `--help` output before the list
291		// of options. This is typically a summary of the program functionality.	291		// of options. This is typically a summary of the program functionality.

@@ -293,9 +293,9 @@ var xOptionContextSetSummary func(uintptr, string)
293		// Note that the summary is translated (see	293		// Note that the summary is translated (see
294		// g_option_context_set_translate_func() and	294		// g_option_context_set_translate_func() and
295		// g_option_context_set_translation_domain()).	295		// g_option_context_set_translation_domain()).
296	-	func (x *OptionContext) SetSummary(SummaryVar string) {	296	+	func (x OptionContext) SetSummary(SummaryVar string) {
297			297
298	-	xOptionContextSetSummary(x.GoPointer(), SummaryVar)	298	+	xOptionContextSetSummary(x.GoPointer(), core.NullableStringToPtr(SummaryVar))
299			299
300		}	300		}
301			301

@@ -314,7 +314,37 @@ var xOptionContextSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
314		// domain, see g_option_context_set_translation_domain().	314		// domain, see g_option_context_set_translation_domain().
315		func (x OptionContext) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {	315		func (x OptionContext) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
316			316
317	-	xOptionContextSetTranslateFunc(x.GoPointer(), NewCallbackNullable(FuncVar), DataVar, NewCallbackNullable(DestroyNotifyVar))	317	+	var FuncVarRef uintptr
			318	+	if FuncVar != nil {
			319	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			320	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			321	+	FuncVarRef = cbRefPtr
			322	+	} else {
			323	+	fcb := func(arg0 string, arg1 uintptr) string {
			324	+	cbFn := *FuncVar
			325	+	return cbFn(arg0, arg1)
			326	+	}
			327	+	FuncVarRef = purego.NewCallback(fcb)
			328	+	SaveCallback(FuncVarPtr, FuncVarRef)
			329	+	}
			330	+	}
			331	+
			332	+	var DestroyNotifyVarRef uintptr
			333	+	if DestroyNotifyVar != nil {
			334	+	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
			335	+	if cbRefPtr, ok := GetCallback(DestroyNotifyVarPtr); ok {
			336	+	DestroyNotifyVarRef = cbRefPtr
			337	+	} else {
			338	+	fcb := func(arg0 uintptr) {
			339	+	cbFn := *DestroyNotifyVar
			340	+	cbFn(arg0)
			341	+	}
			342	+	DestroyNotifyVarRef = purego.NewCallback(fcb)
			343	+	SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
			344	+	}
			345	+	}
			346	+
			347	+	xOptionContextSetTranslateFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyNotifyVarRef)
318			348
319		}	349		}
320			350

@@ -404,7 +434,22 @@ var xNewOptionGroup func(string, string, string, uintptr, uintptr) *OptionGroup
404		// ‘Application Options:’.	434		// ‘Application Options:’.
405		func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar DestroyNotify) OptionGroup {	435		func NewOptionGroup(NameVar string, DescriptionVar string, HelpDescriptionVar string, UserDataVar uintptr, DestroyVar DestroyNotify) OptionGroup {
406			436
407	-	cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, NewCallbackNullable(DestroyVar))	437	+	var DestroyVarRef uintptr
			438	+	if DestroyVar != nil {
			439	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			440	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
			441	+	DestroyVarRef = cbRefPtr
			442	+	} else {
			443	+	fcb := func(arg0 uintptr) {
			444	+	cbFn := *DestroyVar
			445	+	cbFn(arg0)
			446	+	}
			447	+	DestroyVarRef = purego.NewCallback(fcb)
			448	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
			449	+	}
			450	+	}
			451	+
			452	+	cret := xNewOptionGroup(NameVar, DescriptionVar, HelpDescriptionVar, UserDataVar, DestroyVarRef)
408		return cret	453		return cret
409		}	454		}
410			455

@@ -445,7 +490,22 @@ var xOptionGroupSetErrorHook func(uintptr, uintptr)
445		// specified when constructing the group with g_option_group_new().	490		// specified when constructing the group with g_option_group_new().
446		func (x OptionGroup) SetErrorHook(ErrorFuncVar OptionErrorFunc) {	491		func (x OptionGroup) SetErrorHook(ErrorFuncVar OptionErrorFunc) {
447			492
448	-	xOptionGroupSetErrorHook(x.GoPointer(), NewCallback(ErrorFuncVar))	493	+	var ErrorFuncVarRef uintptr
			494	+	if ErrorFuncVar != nil {
			495	+	ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
			496	+	if cbRefPtr, ok := GetCallback(ErrorFuncVarPtr); ok {
			497	+	ErrorFuncVarRef = cbRefPtr
			498	+	} else {
			499	+	fcb := func(arg0 OptionContext, arg1 OptionGroup, arg2 uintptr, arg3 **Error) {
			500	+	cbFn := *ErrorFuncVar
			501	+	cbFn(arg0, arg1, arg2, arg3)
			502	+	}
			503	+	ErrorFuncVarRef = purego.NewCallback(fcb)
			504	+	SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
			505	+	}
			506	+	}
			507	+
			508	+	xOptionGroupSetErrorHook(x.GoPointer(), ErrorFuncVarRef)
449			509
450		}	510		}
451			511

@@ -460,7 +520,37 @@ var xOptionGroupSetParseHooks func(uintptr, uintptr, uintptr)
460		// with g_option_group_new().	520		// with g_option_group_new().
461		func (x OptionGroup) SetParseHooks(PreParseFuncVar OptionParseFunc, PostParseFuncVar *OptionParseFunc) {	521		func (x OptionGroup) SetParseHooks(PreParseFuncVar OptionParseFunc, PostParseFuncVar *OptionParseFunc) {
462			522
463	-	xOptionGroupSetParseHooks(x.GoPointer(), NewCallbackNullable(PreParseFuncVar), NewCallbackNullable(PostParseFuncVar))	523	+	var PreParseFuncVarRef uintptr
			524	+	if PreParseFuncVar != nil {
			525	+	PreParseFuncVarPtr := uintptr(unsafe.Pointer(PreParseFuncVar))
			526	+	if cbRefPtr, ok := GetCallback(PreParseFuncVarPtr); ok {
			527	+	PreParseFuncVarRef = cbRefPtr
			528	+	} else {
			529	+	fcb := func(arg0 OptionContext, arg1 OptionGroup, arg2 uintptr, arg3 **Error) bool {
			530	+	cbFn := *PreParseFuncVar
			531	+	return cbFn(arg0, arg1, arg2, arg3)
			532	+	}
			533	+	PreParseFuncVarRef = purego.NewCallback(fcb)
			534	+	SaveCallback(PreParseFuncVarPtr, PreParseFuncVarRef)
			535	+	}
			536	+	}
			537	+
			538	+	var PostParseFuncVarRef uintptr
			539	+	if PostParseFuncVar != nil {
			540	+	PostParseFuncVarPtr := uintptr(unsafe.Pointer(PostParseFuncVar))
			541	+	if cbRefPtr, ok := GetCallback(PostParseFuncVarPtr); ok {
			542	+	PostParseFuncVarRef = cbRefPtr
			543	+	} else {
			544	+	fcb := func(arg0 OptionContext, arg1 OptionGroup, arg2 uintptr, arg3 **Error) bool {
			545	+	cbFn := *PostParseFuncVar
			546	+	return cbFn(arg0, arg1, arg2, arg3)
			547	+	}
			548	+	PostParseFuncVarRef = purego.NewCallback(fcb)
			549	+	SaveCallback(PostParseFuncVarPtr, PostParseFuncVarRef)
			550	+	}
			551	+	}
			552	+
			553	+	xOptionGroupSetParseHooks(x.GoPointer(), PreParseFuncVarRef, PostParseFuncVarRef)
464			554
465		}	555		}
466			556

@@ -474,7 +564,37 @@ var xOptionGroupSetTranslateFunc func(uintptr, uintptr, uintptr, uintptr)
474		// domain, see g_option_group_set_translation_domain().	564		// domain, see g_option_group_set_translation_domain().
475		func (x OptionGroup) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {	565		func (x OptionGroup) SetTranslateFunc(FuncVar TranslateFunc, DataVar uintptr, DestroyNotifyVar *DestroyNotify) {
476			566
477	-	xOptionGroupSetTranslateFunc(x.GoPointer(), NewCallbackNullable(FuncVar), DataVar, NewCallbackNullable(DestroyNotifyVar))	567	+	var FuncVarRef uintptr
			568	+	if FuncVar != nil {
			569	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			570	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			571	+	FuncVarRef = cbRefPtr
			572	+	} else {
			573	+	fcb := func(arg0 string, arg1 uintptr) string {
			574	+	cbFn := *FuncVar
			575	+	return cbFn(arg0, arg1)
			576	+	}
			577	+	FuncVarRef = purego.NewCallback(fcb)
			578	+	SaveCallback(FuncVarPtr, FuncVarRef)
			579	+	}
			580	+	}
			581	+
			582	+	var DestroyNotifyVarRef uintptr
			583	+	if DestroyNotifyVar != nil {
			584	+	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
			585	+	if cbRefPtr, ok := GetCallback(DestroyNotifyVarPtr); ok {
			586	+	DestroyNotifyVarRef = cbRefPtr
			587	+	} else {
			588	+	fcb := func(arg0 uintptr) {
			589	+	cbFn := *DestroyNotifyVar
			590	+	cbFn(arg0)
			591	+	}
			592	+	DestroyNotifyVarRef = purego.NewCallback(fcb)
			593	+	SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
			594	+	}
			595	+	}
			596	+
			597	+	xOptionGroupSetTranslateFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyNotifyVarRef)
478			598
479		}	599		}
480			600

M v4/glib/gpathbuf.go +6 -6


@@ -116,12 +116,12 @@ func (x PathBuf) Init() PathBuf {
116		return cret	116		return cret
117		}	117		}
118			118
119	-	var xPathBufInitFromPath func(uintptr, string) *PathBuf	119	+	var xPathBufInitFromPath func(uintptr, uintptr) *PathBuf
120			120
121		// Initializes a `GPathBuf` instance with the given path.	121		// Initializes a `GPathBuf` instance with the given path.
122	-	func (x PathBuf) InitFromPath(PathVar string) PathBuf {	122	+	func (x PathBuf) InitFromPath(PathVar string) *PathBuf {
123			123
124	-	cret := xPathBufInitFromPath(x.GoPointer(), PathVar)	124	+	cret := xPathBufInitFromPath(x.GoPointer(), core.NullableStringToPtr(PathVar))
125		return cret	125		return cret
126		}	126		}
127			127

@@ -191,7 +191,7 @@ func (x PathBuf) Push(PathVar string) PathBuf {
191		return cret	191		return cret
192		}	192		}
193			193
194	-	var xPathBufSetExtension func(uintptr, string) bool	194	+	var xPathBufSetExtension func(uintptr, uintptr) bool
195			195
196		// Adds an extension to the file name in the path buffer.	196		// Adds an extension to the file name in the path buffer.
197		//	197		//

@@ -199,9 +199,9 @@ var xPathBufSetExtension func(uintptr, string) bool
199		//	199		//
200		// If the path buffer does not have a file name set, this function returns	200		// If the path buffer does not have a file name set, this function returns
201		// `FALSE` and leaves the path buffer unmodified.	201		// `FALSE` and leaves the path buffer unmodified.
202	-	func (x *PathBuf) SetExtension(ExtensionVar string) bool {	202	+	func (x PathBuf) SetExtension(ExtensionVar string) bool {
203			203
204	-	cret := xPathBufSetExtension(x.GoPointer(), ExtensionVar)	204	+	cret := xPathBufSetExtension(x.GoPointer(), core.NullableStringToPtr(ExtensionVar))
205		return cret	205		return cret
206		}	206		}
207			207

M v4/glib/gpattern.go +6 -6


@@ -77,7 +77,7 @@ func (x *PatternSpec) Free() {
77			77
78		}	78		}
79			79
80	-	var xPatternSpecMatch func(uintptr, uint, string, string) bool	80	+	var xPatternSpecMatch func(uintptr, uint, string, uintptr) bool
81			81
82		// Matches a string against a compiled pattern.	82		// Matches a string against a compiled pattern.
83		//	83		//

@@ -98,9 +98,9 @@ var xPatternSpecMatch func(uintptr, uint, string, string) bool
98		// not be obtained by [func@GLib.strreverse]. This works only if the string	98		// not be obtained by [func@GLib.strreverse]. This works only if the string
99		// does not contain any multibyte characters. GLib offers the	99		// does not contain any multibyte characters. GLib offers the
100		// [func@GLib.utf8_strreverse] function to reverse UTF-8 encoded strings.	100		// [func@GLib.utf8_strreverse] function to reverse UTF-8 encoded strings.
101	-	func (x *PatternSpec) Match(StringLengthVar uint, StringVar string, StringReversedVar string) bool {	101	+	func (x PatternSpec) Match(StringLengthVar uint, StringVar string, StringReversedVar string) bool {
102			102
103	-	cret := xPatternSpecMatch(x.GoPointer(), StringLengthVar, StringVar, StringReversedVar)	103	+	cret := xPatternSpecMatch(x.GoPointer(), StringLengthVar, StringVar, core.NullableStringToPtr(StringReversedVar))
104		return cret	104		return cret
105		}	105		}
106			106

@@ -117,7 +117,7 @@ func (x *PatternSpec) MatchString(StringVar string) bool {
117		return cret	117		return cret
118		}	118		}
119			119
120	-	var xPatternMatch func(*PatternSpec, uint, string, string) bool	120	+	var xPatternMatch func(*PatternSpec, uint, string, uintptr) bool
121			121
122		// Matches a string against a compiled pattern.	122		// Matches a string against a compiled pattern.
123		//	123		//

@@ -138,9 +138,9 @@ var xPatternMatch func(*PatternSpec, uint, string, string) bool
138		// not be obtained by [func@GLib.strreverse]. This works only if the string	138		// not be obtained by [func@GLib.strreverse]. This works only if the string
139		// does not contain any multibyte characters. GLib offers the	139		// does not contain any multibyte characters. GLib offers the
140		// [func@GLib.utf8_strreverse] function to reverse UTF-8 encoded strings.	140		// [func@GLib.utf8_strreverse] function to reverse UTF-8 encoded strings.
141	-	func PatternMatch(PspecVar *PatternSpec, StringLengthVar uint, StringVar string, StringReversedVar string) bool {	141	+	func PatternMatch(PspecVar PatternSpec, StringLengthVar uint, StringVar string, StringReversedVar string) bool {
142			142
143	-	cret := xPatternMatch(PspecVar, StringLengthVar, StringVar, StringReversedVar)	143	+	cret := xPatternMatch(PspecVar, StringLengthVar, StringVar, core.NullableStringToPtr(StringReversedVar))
144		return cret	144		return cret
145		}	145		}
146			146

M v4/glib/gqsort.go +34 -2


@@ -2,6 +2,8 @@
2		package glib	2		package glib
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	9		)

@@ -15,7 +17,22 @@ var xQsortWithData func(uintptr, int, uint, uintptr, uintptr)
15		// Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).	17		// Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
16		func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {	18		func QsortWithData(PbaseVar uintptr, TotalElemsVar int, SizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
17			19
18	-	xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, NewCallback(CompareFuncVar), UserDataVar)	20	+	var CompareFuncVarRef uintptr
			21	+	if CompareFuncVar != nil {
			22	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			23	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
			24	+	CompareFuncVarRef = cbRefPtr
			25	+	} else {
			26	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			27	+	cbFn := *CompareFuncVar
			28	+	return cbFn(arg0, arg1, arg2)
			29	+	}
			30	+	CompareFuncVarRef = purego.NewCallback(fcb)
			31	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			32	+	}
			33	+	}
			34	+
			35	+	xQsortWithData(PbaseVar, TotalElemsVar, SizeVar, CompareFuncVarRef, UserDataVar)
19			36
20		}	37		}
21			38

@@ -28,7 +45,22 @@ var xSortArray func([]uintptr, uint, uint, uintptr, uintptr)
28		// Unlike `qsort()`, this is guaranteed to be a stable sort.	45		// Unlike `qsort()`, this is guaranteed to be a stable sort.
29		func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {	46		func SortArray(ArrayVar []uintptr, NElementsVar uint, ElementSizeVar uint, CompareFuncVar *CompareDataFunc, UserDataVar uintptr) {
30			47
31	-	xSortArray(ArrayVar, NElementsVar, ElementSizeVar, NewCallback(CompareFuncVar), UserDataVar)	48	+	var CompareFuncVarRef uintptr
			49	+	if CompareFuncVar != nil {
			50	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			51	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
			52	+	CompareFuncVarRef = cbRefPtr
			53	+	} else {
			54	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			55	+	cbFn := *CompareFuncVar
			56	+	return cbFn(arg0, arg1, arg2)
			57	+	}
			58	+	CompareFuncVarRef = purego.NewCallback(fcb)
			59	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			60	+	}
			61	+	}
			62	+
			63	+	xSortArray(ArrayVar, NElementsVar, ElementSizeVar, CompareFuncVarRef, UserDataVar)
32			64
33		}	65		}
34			66

M v4/glib/gquark.go +15 -15


@@ -34,7 +34,7 @@ import (
34		// pointer comparison, rather than using `strcmp()`.	34		// pointer comparison, rather than using `strcmp()`.
35		type Quark = uint32	35		type Quark = uint32
36			36
37	-	var xInternStaticString func(string) string	37	+	var xInternStaticString func(uintptr) string
38			38
39		// Returns a canonical representation for @string. Interned strings	39		// Returns a canonical representation for @string. Interned strings
40		// can be compared for equality by comparing the pointers, instead of	40		// can be compared for equality by comparing the pointers, instead of

@@ -44,13 +44,13 @@ var xInternStaticString func(string) string
44		// This function must not be used before library constructors have finished	44		// This function must not be used before library constructors have finished
45		// running. In particular, this means it cannot be used to initialize global	45		// running. In particular, this means it cannot be used to initialize global
46		// variables in C++.	46		// variables in C++.
47	-	func InternStaticString(StringVar string) string {	47	+	func InternStaticString(StringVar *string) string {
48			48
49	-	cret := xInternStaticString(StringVar)	49	+	cret := xInternStaticString(core.NullableStringToPtr(StringVar))
50		return cret	50		return cret
51		}	51		}
52			52
53	-	var xInternString func(string) string	53	+	var xInternString func(uintptr) string
54			54
55		// Returns a canonical representation for @string. Interned strings	55		// Returns a canonical representation for @string. Interned strings
56		// can be compared for equality by comparing the pointers, instead of	56		// can be compared for equality by comparing the pointers, instead of

@@ -59,13 +59,13 @@ var xInternString func(string) string
59		// This function must not be used before library constructors have finished	59		// This function must not be used before library constructors have finished
60		// running. In particular, this means it cannot be used to initialize global	60		// running. In particular, this means it cannot be used to initialize global
61		// variables in C++.	61		// variables in C++.
62	-	func InternString(StringVar string) string {	62	+	func InternString(StringVar *string) string {
63			63
64	-	cret := xInternString(StringVar)	64	+	cret := xInternString(core.NullableStringToPtr(StringVar))
65		return cret	65		return cret
66		}	66		}
67			67
68	-	var xQuarkFromStaticString func(string) Quark	68	+	var xQuarkFromStaticString func(uintptr) Quark
69			69
70		// Gets the #GQuark identifying the given (static) string. If the	70		// Gets the #GQuark identifying the given (static) string. If the
71		// string does not currently have an associated #GQuark, a new #GQuark	71		// string does not currently have an associated #GQuark, a new #GQuark

@@ -83,13 +83,13 @@ var xQuarkFromStaticString func(string) Quark
83		// This function must not be used before library constructors have finished	83		// This function must not be used before library constructors have finished
84		// running. In particular, this means it cannot be used to initialize global	84		// running. In particular, this means it cannot be used to initialize global
85		// variables in C++.	85		// variables in C++.
86	-	func QuarkFromStaticString(StringVar string) Quark {	86	+	func QuarkFromStaticString(StringVar *string) Quark {
87			87
88	-	cret := xQuarkFromStaticString(StringVar)	88	+	cret := xQuarkFromStaticString(core.NullableStringToPtr(StringVar))
89		return cret	89		return cret
90		}	90		}
91			91
92	-	var xQuarkFromString func(string) Quark	92	+	var xQuarkFromString func(uintptr) Quark
93			93
94		// Gets the #GQuark identifying the given string. If the string does	94		// Gets the #GQuark identifying the given string. If the string does
95		// not currently have an associated #GQuark, a new #GQuark is created,	95		// not currently have an associated #GQuark, a new #GQuark is created,

@@ -98,9 +98,9 @@ var xQuarkFromString func(string) Quark
98		// This function must not be used before library constructors have finished	98		// This function must not be used before library constructors have finished
99		// running. In particular, this means it cannot be used to initialize global	99		// running. In particular, this means it cannot be used to initialize global
100		// variables in C++.	100		// variables in C++.
101	-	func QuarkFromString(StringVar string) Quark {	101	+	func QuarkFromString(StringVar *string) Quark {
102			102
103	-	cret := xQuarkFromString(StringVar)	103	+	cret := xQuarkFromString(core.NullableStringToPtr(StringVar))
104		return cret	104		return cret
105		}	105		}
106			106

@@ -113,7 +113,7 @@ func QuarkToString(QuarkVar Quark) string {
113		return cret	113		return cret
114		}	114		}
115			115
116	-	var xQuarkTryString func(string) Quark	116	+	var xQuarkTryString func(uintptr) Quark
117			117
118		// Gets the #GQuark associated with the given string, or 0 if string is	118		// Gets the #GQuark associated with the given string, or 0 if string is
119		// %NULL or it has no associated #GQuark.	119		// %NULL or it has no associated #GQuark.

@@ -123,9 +123,9 @@ var xQuarkTryString func(string) Quark
123		//	123		//
124		// This function must not be used before library constructors have finished	124		// This function must not be used before library constructors have finished
125		// running.	125		// running.
126	-	func QuarkTryString(StringVar string) Quark {	126	+	func QuarkTryString(StringVar *string) Quark {
127			127
128	-	cret := xQuarkTryString(StringVar)	128	+	cret := xQuarkTryString(core.NullableStringToPtr(StringVar))
129		return cret	129		return cret
130		}	130		}
131			131

M v4/glib/gqueue.go +96 -6


@@ -41,7 +41,22 @@ var xQueueClearFull func(uintptr, uintptr)
41		// and calls the provided @free_func on each item in the #GQueue.	41		// and calls the provided @free_func on each item in the #GQueue.
42		func (x Queue) ClearFull(FreeFuncVar DestroyNotify) {	42		func (x Queue) ClearFull(FreeFuncVar DestroyNotify) {
43			43
44	-	xQueueClearFull(x.GoPointer(), NewCallbackNullable(FreeFuncVar))	44	+	var FreeFuncVarRef uintptr
			45	+	if FreeFuncVar != nil {
			46	+	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
			47	+	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
			48	+	FreeFuncVarRef = cbRefPtr
			49	+	} else {
			50	+	fcb := func(arg0 uintptr) {
			51	+	cbFn := *FreeFuncVar
			52	+	cbFn(arg0)
			53	+	}
			54	+	FreeFuncVarRef = purego.NewCallback(fcb)
			55	+	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
			56	+	}
			57	+	}
			58	+
			59	+	xQueueClearFull(x.GoPointer(), FreeFuncVarRef)
45			60
46		}	61		}
47			62

@@ -85,7 +100,22 @@ var xQueueFindCustom func(uintptr, uintptr, uintptr) *List
85		// first argument and the given user data as the second argument.	100		// first argument and the given user data as the second argument.
86		func (x Queue) FindCustom(DataVar uintptr, FuncVar CompareFunc) *List {	101		func (x Queue) FindCustom(DataVar uintptr, FuncVar CompareFunc) *List {
87			102
88	-	cret := xQueueFindCustom(x.GoPointer(), DataVar, NewCallback(FuncVar))	103	+	var FuncVarRef uintptr
			104	+	if FuncVar != nil {
			105	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			106	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			107	+	FuncVarRef = cbRefPtr
			108	+	} else {
			109	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			110	+	cbFn := *FuncVar
			111	+	return cbFn(arg0, arg1)
			112	+	}
			113	+	FuncVarRef = purego.NewCallback(fcb)
			114	+	SaveCallback(FuncVarPtr, FuncVarRef)
			115	+	}
			116	+	}
			117	+
			118	+	cret := xQueueFindCustom(x.GoPointer(), DataVar, FuncVarRef)
89		return cret	119		return cret
90		}	120		}
91			121

@@ -98,7 +128,22 @@ var xQueueForeach func(uintptr, uintptr, uintptr)
98		// not modify any part of the queue after that element.	128		// not modify any part of the queue after that element.
99		func (x Queue) Foreach(FuncVar Func, UserDataVar uintptr) {	129		func (x Queue) Foreach(FuncVar Func, UserDataVar uintptr) {
100			130
101	-	xQueueForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	131	+	var FuncVarRef uintptr
			132	+	if FuncVar != nil {
			133	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			134	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			135	+	FuncVarRef = cbRefPtr
			136	+	} else {
			137	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			138	+	cbFn := *FuncVar
			139	+	cbFn(arg0, arg1)
			140	+	}
			141	+	FuncVarRef = purego.NewCallback(fcb)
			142	+	SaveCallback(FuncVarPtr, FuncVarRef)
			143	+	}
			144	+	}
			145	+
			146	+	xQueueForeach(x.GoPointer(), FuncVarRef, UserDataVar)
102			147
103		}	148		}
104			149

@@ -125,7 +170,22 @@ var xQueueFreeFull func(uintptr, uintptr)
125		// element from it).	170		// element from it).
126		func (x Queue) FreeFull(FreeFuncVar DestroyNotify) {	171		func (x Queue) FreeFull(FreeFuncVar DestroyNotify) {
127			172
128	-	xQueueFreeFull(x.GoPointer(), NewCallback(FreeFuncVar))	173	+	var FreeFuncVarRef uintptr
			174	+	if FreeFuncVar != nil {
			175	+	FreeFuncVarPtr := uintptr(unsafe.Pointer(FreeFuncVar))
			176	+	if cbRefPtr, ok := GetCallback(FreeFuncVarPtr); ok {
			177	+	FreeFuncVarRef = cbRefPtr
			178	+	} else {
			179	+	fcb := func(arg0 uintptr) {
			180	+	cbFn := *FreeFuncVar
			181	+	cbFn(arg0)
			182	+	}
			183	+	FreeFuncVarRef = purego.NewCallback(fcb)
			184	+	SaveCallback(FreeFuncVarPtr, FreeFuncVarRef)
			185	+	}
			186	+	}
			187	+
			188	+	xQueueFreeFull(x.GoPointer(), FreeFuncVarRef)
129			189
130		}	190		}
131			191

@@ -210,7 +270,22 @@ var xQueueInsertSorted func(uintptr, uintptr, uintptr, uintptr)
210		// Inserts @data into @queue using @func to determine the new position.	270		// Inserts @data into @queue using @func to determine the new position.
211		func (x Queue) InsertSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {	271		func (x Queue) InsertSorted(DataVar uintptr, FuncVar CompareDataFunc, UserDataVar uintptr) {
212			272
213	-	xQueueInsertSorted(x.GoPointer(), DataVar, NewCallback(FuncVar), UserDataVar)	273	+	var FuncVarRef uintptr
			274	+	if FuncVar != nil {
			275	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			276	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			277	+	FuncVarRef = cbRefPtr
			278	+	} else {
			279	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			280	+	cbFn := *FuncVar
			281	+	return cbFn(arg0, arg1, arg2)
			282	+	}
			283	+	FuncVarRef = purego.NewCallback(fcb)
			284	+	SaveCallback(FuncVarPtr, FuncVarRef)
			285	+	}
			286	+	}
			287	+
			288	+	xQueueInsertSorted(x.GoPointer(), DataVar, FuncVarRef, UserDataVar)
214			289
215		}	290		}
216			291

@@ -426,7 +501,22 @@ var xQueueSort func(uintptr, uintptr, uintptr)
426		// Sorts @queue using @compare_func.	501		// Sorts @queue using @compare_func.
427		func (x Queue) Sort(CompareFuncVar CompareDataFunc, UserDataVar uintptr) {	502		func (x Queue) Sort(CompareFuncVar CompareDataFunc, UserDataVar uintptr) {
428			503
429	-	xQueueSort(x.GoPointer(), NewCallback(CompareFuncVar), UserDataVar)	504	+	var CompareFuncVarRef uintptr
			505	+	if CompareFuncVar != nil {
			506	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			507	+	if cbRefPtr, ok := GetCallback(CompareFuncVarPtr); ok {
			508	+	CompareFuncVarRef = cbRefPtr
			509	+	} else {
			510	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			511	+	cbFn := *CompareFuncVar
			512	+	return cbFn(arg0, arg1, arg2)
			513	+	}
			514	+	CompareFuncVarRef = purego.NewCallback(fcb)
			515	+	SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			516	+	}
			517	+	}
			518	+
			519	+	xQueueSort(x.GoPointer(), CompareFuncVarRef, UserDataVar)
430			520
431		}	521		}
432			522

M v4/glib/grcbox.go +34 -2


@@ -2,6 +2,8 @@
2		package glib	2		package glib
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		)	9		)

@@ -95,7 +97,22 @@ var xAtomicRcBoxReleaseFull func(uintptr, uintptr)
95		// when the callback is called and will be freed.	97		// when the callback is called and will be freed.
96		func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {	98		func AtomicRcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
97			99
98	-	xAtomicRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))	100	+	var ClearFuncVarRef uintptr
			101	+	if ClearFuncVar != nil {
			102	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
			103	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
			104	+	ClearFuncVarRef = cbRefPtr
			105	+	} else {
			106	+	fcb := func(arg0 uintptr) {
			107	+	cbFn := *ClearFuncVar
			108	+	cbFn(arg0)
			109	+	}
			110	+	ClearFuncVarRef = purego.NewCallback(fcb)
			111	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
			112	+	}
			113	+	}
			114	+
			115	+	xAtomicRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)
99			116
100		}	117		}
101			118

@@ -183,7 +200,22 @@ var xRcBoxReleaseFull func(uintptr, uintptr)
183		// resources allocated for @mem_block.	200		// resources allocated for @mem_block.
184		func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {	201		func RcBoxReleaseFull(MemBlockVar uintptr, ClearFuncVar *DestroyNotify) {
185			202
186	-	xRcBoxReleaseFull(MemBlockVar, NewCallback(ClearFuncVar))	203	+	var ClearFuncVarRef uintptr
			204	+	if ClearFuncVar != nil {
			205	+	ClearFuncVarPtr := uintptr(unsafe.Pointer(ClearFuncVar))
			206	+	if cbRefPtr, ok := GetCallback(ClearFuncVarPtr); ok {
			207	+	ClearFuncVarRef = cbRefPtr
			208	+	} else {
			209	+	fcb := func(arg0 uintptr) {
			210	+	cbFn := *ClearFuncVar
			211	+	cbFn(arg0)
			212	+	}
			213	+	ClearFuncVarRef = purego.NewCallback(fcb)
			214	+	SaveCallback(ClearFuncVarPtr, ClearFuncVarRef)
			215	+	}
			216	+	}
			217	+
			218	+	xRcBoxReleaseFull(MemBlockVar, ClearFuncVarRef)
187			219
188		}	220		}
189			221

M v4/glib/gregex.go +16 -1


@@ -1028,7 +1028,22 @@ var xRegexReplaceEval func(uintptr, []string, int, int, RegexMatchFlags, uintptr
1028		func (x Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar RegexEvalCallback, UserDataVar uintptr) (string, error) {	1028		func (x Regex) ReplaceEval(StringVar []string, StringLenVar int, StartPositionVar int, MatchOptionsVar RegexMatchFlags, EvalVar RegexEvalCallback, UserDataVar uintptr) (string, error) {
1029		var cerr *Error	1029		var cerr *Error
1030			1030
1031	-	cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, NewCallback(EvalVar), UserDataVar, &cerr)	1031	+	var EvalVarRef uintptr
			1032	+	if EvalVar != nil {
			1033	+	EvalVarPtr := uintptr(unsafe.Pointer(EvalVar))
			1034	+	if cbRefPtr, ok := GetCallback(EvalVarPtr); ok {
			1035	+	EvalVarRef = cbRefPtr
			1036	+	} else {
			1037	+	fcb := func(arg0 MatchInfo, arg1 String, arg2 uintptr) bool {
			1038	+	cbFn := *EvalVar
			1039	+	return cbFn(arg0, arg1, arg2)
			1040	+	}
			1041	+	EvalVarRef = purego.NewCallback(fcb)
			1042	+	SaveCallback(EvalVarPtr, EvalVarRef)
			1043	+	}
			1044	+	}
			1045	+
			1046	+	cret := xRegexReplaceEval(x.GoPointer(), StringVar, StringLenVar, StartPositionVar, MatchOptionsVar, EvalVarRef, UserDataVar, &cerr)
1032		if cerr == nil {	1047		if cerr == nil {
1033		return cret, nil	1048		return cret, nil
1034		}	1049		}

M v4/glib/grel.go +31 -1


@@ -104,7 +104,37 @@ var xRelationIndex func(uintptr, int, uintptr, uintptr)
104		// before any records are added to the #GRelation.	104		// before any records are added to the #GRelation.
105		func (x Relation) Index(FieldVar int, HashFuncVar HashFunc, KeyEqualFuncVar *EqualFunc) {	105		func (x Relation) Index(FieldVar int, HashFuncVar HashFunc, KeyEqualFuncVar *EqualFunc) {
106			106
107	-	xRelationIndex(x.GoPointer(), FieldVar, NewCallback(HashFuncVar), NewCallback(KeyEqualFuncVar))	107	+	var HashFuncVarRef uintptr
			108	+	if HashFuncVar != nil {
			109	+	HashFuncVarPtr := uintptr(unsafe.Pointer(HashFuncVar))
			110	+	if cbRefPtr, ok := GetCallback(HashFuncVarPtr); ok {
			111	+	HashFuncVarRef = cbRefPtr
			112	+	} else {
			113	+	fcb := func(arg0 uintptr) uint {
			114	+	cbFn := *HashFuncVar
			115	+	return cbFn(arg0)
			116	+	}
			117	+	HashFuncVarRef = purego.NewCallback(fcb)
			118	+	SaveCallback(HashFuncVarPtr, HashFuncVarRef)
			119	+	}
			120	+	}
			121	+
			122	+	var KeyEqualFuncVarRef uintptr
			123	+	if KeyEqualFuncVar != nil {
			124	+	KeyEqualFuncVarPtr := uintptr(unsafe.Pointer(KeyEqualFuncVar))
			125	+	if cbRefPtr, ok := GetCallback(KeyEqualFuncVarPtr); ok {
			126	+	KeyEqualFuncVarRef = cbRefPtr
			127	+	} else {
			128	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			129	+	cbFn := *KeyEqualFuncVar
			130	+	return cbFn(arg0, arg1)
			131	+	}
			132	+	KeyEqualFuncVarRef = purego.NewCallback(fcb)
			133	+	SaveCallback(KeyEqualFuncVarPtr, KeyEqualFuncVarRef)
			134	+	}
			135	+	}
			136	+
			137	+	xRelationIndex(x.GoPointer(), FieldVar, HashFuncVarRef, KeyEqualFuncVarRef)
108			138
109		}	139		}
110			140

M v4/glib/gscanner.go +16 -1


@@ -223,7 +223,22 @@ var xScannerScopeForeachSymbol func(uintptr, uint, uintptr, uintptr)
223		// parameter.	223		// parameter.
224		func (x Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar HFunc, UserDataVar uintptr) {	224		func (x Scanner) ScopeForeachSymbol(ScopeIdVar uint, FuncVar HFunc, UserDataVar uintptr) {
225			225
226	-	xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, NewCallback(FuncVar), UserDataVar)	226	+	var FuncVarRef uintptr
			227	+	if FuncVar != nil {
			228	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			229	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			230	+	FuncVarRef = cbRefPtr
			231	+	} else {
			232	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			233	+	cbFn := *FuncVar
			234	+	cbFn(arg0, arg1, arg2)
			235	+	}
			236	+	FuncVarRef = purego.NewCallback(fcb)
			237	+	SaveCallback(FuncVarPtr, FuncVarRef)
			238	+	}
			239	+	}
			240	+
			241	+	xScannerScopeForeachSymbol(x.GoPointer(), ScopeIdVar, FuncVarRef, UserDataVar)
227			242
228		}	243		}
229			244

M v4/glib/gsequence.go +192 -12


@@ -39,7 +39,22 @@ var xSequenceForeach func(uintptr, uintptr, uintptr)
39		// to the function. @func must not modify the sequence itself.	39		// to the function. @func must not modify the sequence itself.
40		func (x Sequence) Foreach(FuncVar Func, UserDataVar uintptr) {	40		func (x Sequence) Foreach(FuncVar Func, UserDataVar uintptr) {
41			41
42	-	xSequenceForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	42	+	var FuncVarRef uintptr
			43	+	if FuncVar != nil {
			44	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			45	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			46	+	FuncVarRef = cbRefPtr
			47	+	} else {
			48	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			49	+	cbFn := *FuncVar
			50	+	cbFn(arg0, arg1)
			51	+	}
			52	+	FuncVarRef = purego.NewCallback(fcb)
			53	+	SaveCallback(FuncVarPtr, FuncVarRef)
			54	+	}
			55	+	}
			56	+
			57	+	xSequenceForeach(x.GoPointer(), FuncVarRef, UserDataVar)
43			58
44		}	59		}
45			60

@@ -109,7 +124,22 @@ var xSequenceInsertSorted func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
109		// g_sequence_sort() or g_sequence_sort_iter().	124		// g_sequence_sort() or g_sequence_sort_iter().
110		func (x Sequence) InsertSorted(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {	125		func (x Sequence) InsertSorted(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
111			126
112	-	cret := xSequenceInsertSorted(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)	127	+	var CmpFuncVarRef uintptr
			128	+	if CmpFuncVar != nil {
			129	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			130	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			131	+	CmpFuncVarRef = cbRefPtr
			132	+	} else {
			133	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			134	+	cbFn := *CmpFuncVar
			135	+	return cbFn(arg0, arg1, arg2)
			136	+	}
			137	+	CmpFuncVarRef = purego.NewCallback(fcb)
			138	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			139	+	}
			140	+	}
			141	+
			142	+	cret := xSequenceInsertSorted(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
113		return cret	143		return cret
114		}	144		}
115			145

@@ -129,7 +159,22 @@ var xSequenceInsertSortedIter func(uintptr, uintptr, uintptr, uintptr) *Sequence
129		// g_sequence_sort() or g_sequence_sort_iter().	159		// g_sequence_sort() or g_sequence_sort_iter().
130		func (x Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {	160		func (x Sequence) InsertSortedIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
131			161
132	-	cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)	162	+	var IterCmpVarRef uintptr
			163	+	if IterCmpVar != nil {
			164	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
			165	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
			166	+	IterCmpVarRef = cbRefPtr
			167	+	} else {
			168	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
			169	+	cbFn := *IterCmpVar
			170	+	return cbFn(arg0, arg1, arg2)
			171	+	}
			172	+	IterCmpVarRef = purego.NewCallback(fcb)
			173	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
			174	+	}
			175	+	}
			176	+
			177	+	cret := xSequenceInsertSortedIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
133		return cret	178		return cret
134		}	179		}
135			180

@@ -163,7 +208,22 @@ var xSequenceLookup func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
163		// unsorted.	208		// unsorted.
164		func (x Sequence) Lookup(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {	209		func (x Sequence) Lookup(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
165			210
166	-	cret := xSequenceLookup(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)	211	+	var CmpFuncVarRef uintptr
			212	+	if CmpFuncVar != nil {
			213	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			214	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			215	+	CmpFuncVarRef = cbRefPtr
			216	+	} else {
			217	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			218	+	cbFn := *CmpFuncVar
			219	+	return cbFn(arg0, arg1, arg2)
			220	+	}
			221	+	CmpFuncVarRef = purego.NewCallback(fcb)
			222	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			223	+	}
			224	+	}
			225	+
			226	+	cret := xSequenceLookup(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
167		return cret	227		return cret
168		}	228		}
169			229

@@ -181,7 +241,22 @@ var xSequenceLookupIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
181		// unsorted.	241		// unsorted.
182		func (x Sequence) LookupIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {	242		func (x Sequence) LookupIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
183			243
184	-	cret := xSequenceLookupIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)	244	+	var IterCmpVarRef uintptr
			245	+	if IterCmpVar != nil {
			246	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
			247	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
			248	+	IterCmpVarRef = cbRefPtr
			249	+	} else {
			250	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
			251	+	cbFn := *IterCmpVar
			252	+	return cbFn(arg0, arg1, arg2)
			253	+	}
			254	+	IterCmpVarRef = purego.NewCallback(fcb)
			255	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
			256	+	}
			257	+	}
			258	+
			259	+	cret := xSequenceLookupIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
185		return cret	260		return cret
186		}	261		}
187			262

@@ -211,7 +286,22 @@ var xSequenceSearch func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
211		// unsorted.	286		// unsorted.
212		func (x Sequence) Search(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {	287		func (x Sequence) Search(DataVar uintptr, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) *SequenceIter {
213			288
214	-	cret := xSequenceSearch(x.GoPointer(), DataVar, NewCallback(CmpFuncVar), CmpDataVar)	289	+	var CmpFuncVarRef uintptr
			290	+	if CmpFuncVar != nil {
			291	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			292	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			293	+	CmpFuncVarRef = cbRefPtr
			294	+	} else {
			295	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			296	+	cbFn := *CmpFuncVar
			297	+	return cbFn(arg0, arg1, arg2)
			298	+	}
			299	+	CmpFuncVarRef = purego.NewCallback(fcb)
			300	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			301	+	}
			302	+	}
			303	+
			304	+	cret := xSequenceSearch(x.GoPointer(), DataVar, CmpFuncVarRef, CmpDataVar)
215		return cret	305		return cret
216		}	306		}
217			307

@@ -232,7 +322,22 @@ var xSequenceSearchIter func(uintptr, uintptr, uintptr, uintptr) *SequenceIter
232		// unsorted.	322		// unsorted.
233		func (x Sequence) SearchIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {	323		func (x Sequence) SearchIter(DataVar uintptr, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) *SequenceIter {
234			324
235	-	cret := xSequenceSearchIter(x.GoPointer(), DataVar, NewCallback(IterCmpVar), CmpDataVar)	325	+	var IterCmpVarRef uintptr
			326	+	if IterCmpVar != nil {
			327	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
			328	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
			329	+	IterCmpVarRef = cbRefPtr
			330	+	} else {
			331	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
			332	+	cbFn := *IterCmpVar
			333	+	return cbFn(arg0, arg1, arg2)
			334	+	}
			335	+	IterCmpVarRef = purego.NewCallback(fcb)
			336	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
			337	+	}
			338	+	}
			339	+
			340	+	cret := xSequenceSearchIter(x.GoPointer(), DataVar, IterCmpVarRef, CmpDataVar)
236		return cret	341		return cret
237		}	342		}
238			343

@@ -246,7 +351,22 @@ var xSequenceSort func(uintptr, uintptr, uintptr)
246		// if the second comes before the first.	351		// if the second comes before the first.
247		func (x Sequence) Sort(CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {	352		func (x Sequence) Sort(CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {
248			353
249	-	xSequenceSort(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)	354	+	var CmpFuncVarRef uintptr
			355	+	if CmpFuncVar != nil {
			356	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			357	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			358	+	CmpFuncVarRef = cbRefPtr
			359	+	} else {
			360	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			361	+	cbFn := *CmpFuncVar
			362	+	return cbFn(arg0, arg1, arg2)
			363	+	}
			364	+	CmpFuncVarRef = purego.NewCallback(fcb)
			365	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			366	+	}
			367	+	}
			368	+
			369	+	xSequenceSort(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
250			370
251		}	371		}
252			372

@@ -261,7 +381,22 @@ var xSequenceSortIter func(uintptr, uintptr, uintptr)
261		// iterator comes before the first.	381		// iterator comes before the first.
262		func (x Sequence) SortIter(CmpFuncVar SequenceIterCompareFunc, CmpDataVar uintptr) {	382		func (x Sequence) SortIter(CmpFuncVar SequenceIterCompareFunc, CmpDataVar uintptr) {
263			383
264	-	xSequenceSortIter(x.GoPointer(), NewCallback(CmpFuncVar), CmpDataVar)	384	+	var CmpFuncVarRef uintptr
			385	+	if CmpFuncVar != nil {
			386	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			387	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			388	+	CmpFuncVarRef = cbRefPtr
			389	+	} else {
			390	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
			391	+	cbFn := *CmpFuncVar
			392	+	return cbFn(arg0, arg1, arg2)
			393	+	}
			394	+	CmpFuncVarRef = purego.NewCallback(fcb)
			395	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			396	+	}
			397	+	}
			398	+
			399	+	xSequenceSortIter(x.GoPointer(), CmpFuncVarRef, CmpDataVar)
265			400
266		}	401		}
267			402

@@ -362,7 +497,22 @@ var xSequenceForeachRange func(SequenceIter, SequenceIter, uintptr, uintptr)
362		// itself.	497		// itself.
363		func SequenceForeachRange(BeginVar SequenceIter, EndVar SequenceIter, FuncVar *Func, UserDataVar uintptr) {	498		func SequenceForeachRange(BeginVar SequenceIter, EndVar SequenceIter, FuncVar *Func, UserDataVar uintptr) {
364			499
365	-	xSequenceForeachRange(BeginVar, EndVar, NewCallback(FuncVar), UserDataVar)	500	+	var FuncVarRef uintptr
			501	+	if FuncVar != nil {
			502	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			503	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			504	+	FuncVarRef = cbRefPtr
			505	+	} else {
			506	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			507	+	cbFn := *FuncVar
			508	+	cbFn(arg0, arg1)
			509	+	}
			510	+	FuncVarRef = purego.NewCallback(fcb)
			511	+	SaveCallback(FuncVarPtr, FuncVarRef)
			512	+	}
			513	+	}
			514	+
			515	+	xSequenceForeachRange(BeginVar, EndVar, FuncVarRef, UserDataVar)
366			516
367		}	517		}
368			518

@@ -476,7 +626,22 @@ var xSequenceSortChanged func(*SequenceIter, uintptr, uintptr)
476		// the second item comes before the first.	626		// the second item comes before the first.
477		func SequenceSortChanged(IterVar SequenceIter, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {	627		func SequenceSortChanged(IterVar SequenceIter, CmpFuncVar CompareDataFunc, CmpDataVar uintptr) {
478			628
479	-	xSequenceSortChanged(IterVar, NewCallback(CmpFuncVar), CmpDataVar)	629	+	var CmpFuncVarRef uintptr
			630	+	if CmpFuncVar != nil {
			631	+	CmpFuncVarPtr := uintptr(unsafe.Pointer(CmpFuncVar))
			632	+	if cbRefPtr, ok := GetCallback(CmpFuncVarPtr); ok {
			633	+	CmpFuncVarRef = cbRefPtr
			634	+	} else {
			635	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			636	+	cbFn := *CmpFuncVar
			637	+	return cbFn(arg0, arg1, arg2)
			638	+	}
			639	+	CmpFuncVarRef = purego.NewCallback(fcb)
			640	+	SaveCallback(CmpFuncVarPtr, CmpFuncVarRef)
			641	+	}
			642	+	}
			643	+
			644	+	xSequenceSortChanged(IterVar, CmpFuncVarRef, CmpDataVar)
480			645
481		}	646		}
482			647

@@ -493,7 +658,22 @@ var xSequenceSortChangedIter func(*SequenceIter, uintptr, uintptr)
493		// iterator comes before the first.	658		// iterator comes before the first.
494		func SequenceSortChangedIter(IterVar SequenceIter, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) {	659		func SequenceSortChangedIter(IterVar SequenceIter, IterCmpVar SequenceIterCompareFunc, CmpDataVar uintptr) {
495			660
496	-	xSequenceSortChangedIter(IterVar, NewCallback(IterCmpVar), CmpDataVar)	661	+	var IterCmpVarRef uintptr
			662	+	if IterCmpVar != nil {
			663	+	IterCmpVarPtr := uintptr(unsafe.Pointer(IterCmpVar))
			664	+	if cbRefPtr, ok := GetCallback(IterCmpVarPtr); ok {
			665	+	IterCmpVarRef = cbRefPtr
			666	+	} else {
			667	+	fcb := func(arg0 SequenceIter, arg1 SequenceIter, arg2 uintptr) int {
			668	+	cbFn := *IterCmpVar
			669	+	return cbFn(arg0, arg1, arg2)
			670	+	}
			671	+	IterCmpVarRef = purego.NewCallback(fcb)
			672	+	SaveCallback(IterCmpVarPtr, IterCmpVarRef)
			673	+	}
			674	+	}
			675	+
			676	+	xSequenceSortChangedIter(IterVar, IterCmpVarRef, CmpDataVar)
497			677
498		}	678		}
499			679

M v4/glib/gslist.go +16 -1


@@ -30,7 +30,22 @@ var xClearSlist func(**SList, uintptr)
30		// @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.	30		// @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing.
31		func ClearSlist(SlistPtrVar *SList, DestroyVar DestroyNotify) {	31		func ClearSlist(SlistPtrVar *SList, DestroyVar DestroyNotify) {
32			32
33	-	xClearSlist(SlistPtrVar, NewCallbackNullable(DestroyVar))	33	+	var DestroyVarRef uintptr
			34	+	if DestroyVar != nil {
			35	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			36	+	if cbRefPtr, ok := GetCallback(DestroyVarPtr); ok {
			37	+	DestroyVarRef = cbRefPtr
			38	+	} else {
			39	+	fcb := func(arg0 uintptr) {
			40	+	cbFn := *DestroyVar
			41	+	cbFn(arg0)
			42	+	}
			43	+	DestroyVarRef = purego.NewCallback(fcb)
			44	+	SaveCallback(DestroyVarPtr, DestroyVarRef)
			45	+	}
			46	+	}
			47	+
			48	+	xClearSlist(SlistPtrVar, DestroyVarRef)
34			49
35		}	50		}
36			51

M v4/glib/gspawn.go +92 -15

 package glib
 import (
+	"unsafe"
 	"github.com/jwijenbergh/purego"
 	"github.com/jwijenbergh/puregotk/pkg/core"
 )
 	GSpawnErrorFailedValue SpawnError = 19
 )
-var xSpawnAsync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, **Error) bool
+var xSpawnAsync func(uintptr, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, **Error) bool
 // Executes a child program asynchronously.
 //
 // Note that the returned @child_pid on Windows is a handle to the child
 // process and not its identifier. Process handles and process identifiers
 // are different concepts on Windows.
-func SpawnAsync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {
+func SpawnAsync(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid) (bool, error) {
 	var cerr *Error
-	cret := xSpawnAsync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, &cerr)
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	cret := xSpawnAsync(core.NullableStringToPtr(WorkingDirectoryVar), ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSpawnAsyncWithFds func(string, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, int, int, int, **Error) bool
+var xSpawnAsyncWithFds func(uintptr, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, int, int, int, **Error) bool
 // Executes a child program asynchronously.
 //
 // Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
 // so no FD assignments are used.
-func SpawnAsyncWithFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
+func SpawnAsyncWithFds(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StdinFdVar int, StdoutFdVar int, StderrFdVar int) (bool, error) {
 	var cerr *Error
-	cret := xSpawnAsyncWithFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	cret := xSpawnAsyncWithFds(core.NullableStringToPtr(WorkingDirectoryVar), ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StdinFdVar, StdoutFdVar, StderrFdVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSpawnAsyncWithPipes func(string, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, *int, *int, *int, **Error) bool
+var xSpawnAsyncWithPipes func(uintptr, []string, []string, SpawnFlags, uintptr, uintptr, *Pid, *int, *int, *int, **Error) bool
 // Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
 // so no FD assignments are used.
-func SpawnAsyncWithPipes(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar *int, StandardOutputVar *int, StandardErrorVar *int) (bool, error) {
+func SpawnAsyncWithPipes(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, ChildPidVar *Pid, StandardInputVar *int, StandardOutputVar *int, StandardErrorVar *int) (bool, error) {
 	var cerr *Error
-	cret := xSpawnAsyncWithPipes(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	cret := xSpawnAsyncWithPipes(core.NullableStringToPtr(WorkingDirectoryVar), ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, ChildPidVar, StandardInputVar, StandardOutputVar, StandardErrorVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSpawnAsyncWithPipesAndFds func(string, []string, []string, SpawnFlags, uintptr, uintptr, int, int, int, []int, []int, uint, *Pid, *int, *int, *int, **Error) bool
+var xSpawnAsyncWithPipesAndFds func(uintptr, []string, []string, SpawnFlags, uintptr, uintptr, int, int, int, []int, []int, uint, *Pid, *int, *int, *int, **Error) bool
 // Executes a child program asynchronously (your program will not
 // block waiting for the child to exit).
 // graphical application too, then to ensure that the spawned program opens its
 // windows on the right screen, you may want to use #GdkAppLaunchContext,
 // #GAppLaunchContext, or set the `DISPLAY` environment variable.
-func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar []int, TargetFdsVar []int, NFdsVar uint, ChildPidOutVar *Pid, StdinPipeOutVar *int, StdoutPipeOutVar *int, StderrPipeOutVar *int) (bool, error) {
+func SpawnAsyncWithPipesAndFds(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StdinFdVar int, StdoutFdVar int, StderrFdVar int, SourceFdsVar []int, TargetFdsVar []int, NFdsVar uint, ChildPidOutVar *Pid, StdinPipeOutVar *int, StdoutPipeOutVar *int, StderrPipeOutVar *int) (bool, error) {
 	var cerr *Error
-	cret := xSpawnAsyncWithPipesAndFds(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	cret := xSpawnAsyncWithPipesAndFds(core.NullableStringToPtr(WorkingDirectoryVar), ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StdinFdVar, StdoutFdVar, StderrFdVar, SourceFdsVar, TargetFdsVar, NFdsVar, ChildPidOutVar, StdinPipeOutVar, StdoutPipeOutVar, StderrPipeOutVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xSpawnSync func(string, []string, []string, SpawnFlags, uintptr, uintptr, *[]byte, *[]byte, *int, **Error) bool
+var xSpawnSync func(uintptr, []string, []string, SpawnFlags, uintptr, uintptr, *[]byte, *[]byte, *int, **Error) bool
 // Executes a child synchronously (waits for the child to exit before returning).
 //
 // This function calls g_spawn_async_with_pipes() internally; see that
 // function for full details on the other parameters and details on
 // how these functions work on Windows.
-func SpawnSync(WorkingDirectoryVar string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar *[]byte, StandardErrorVar *[]byte, WaitStatusVar *int) (bool, error) {
+func SpawnSync(WorkingDirectoryVar *string, ArgvVar []string, EnvpVar []string, FlagsVar SpawnFlags, ChildSetupVar *SpawnChildSetupFunc, UserDataVar uintptr, StandardOutputVar *[]byte, StandardErrorVar *[]byte, WaitStatusVar *int) (bool, error) {
 	var cerr *Error
-	cret := xSpawnSync(WorkingDirectoryVar, ArgvVar, EnvpVar, FlagsVar, NewCallbackNullable(ChildSetupVar), UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
+	var ChildSetupVarRef uintptr
+	if ChildSetupVar != nil {
+		ChildSetupVarPtr := uintptr(unsafe.Pointer(ChildSetupVar))
+		if cbRefPtr, ok := GetCallback(ChildSetupVarPtr); ok {
+			ChildSetupVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *ChildSetupVar
+				cbFn(arg0)
+			}
+			ChildSetupVarRef = purego.NewCallback(fcb)
+			SaveCallback(ChildSetupVarPtr, ChildSetupVarRef)
+		}
+	}
+	cret := xSpawnSync(core.NullableStringToPtr(WorkingDirectoryVar), ArgvVar, EnvpVar, FlagsVar, ChildSetupVarRef, UserDataVar, StandardOutputVar, StandardErrorVar, WaitStatusVar, &cerr)
 	if cerr == nil {
 		return cret, nil
 	}

M v4/glib/gstrfuncs.go +24 -24


@@ -480,7 +480,7 @@ func StrMatchString(SearchTermVar string, PotentialHitVar string, AcceptAlternat
480		return cret	480		return cret
481		}	481		}
482			482
483	-	var xStrToAscii func(string, string) string	483	+	var xStrToAscii func(string, uintptr) string
484			484
485		// Transliterate @str to plain ASCII.	485		// Transliterate @str to plain ASCII.
486		//	486		//

@@ -500,13 +500,13 @@ var xStrToAscii func(string, string) string
500		// If you want to do translation for no specific locale, and you want it	500		// If you want to do translation for no specific locale, and you want it
501		// to be done independently of the currently locale, specify `"C"` for	501		// to be done independently of the currently locale, specify `"C"` for
502		// @from_locale.	502		// @from_locale.
503	-	func StrToAscii(StrVar string, FromLocaleVar string) string {	503	+	func StrToAscii(StrVar string, FromLocaleVar *string) string {
504			504
505	-	cret := xStrToAscii(StrVar, FromLocaleVar)	505	+	cret := xStrToAscii(StrVar, core.NullableStringToPtr(FromLocaleVar))
506		return cret	506		return cret
507		}	507		}
508			508
509	-	var xStrTokenizeAndFold func(string, string, *[]string) []string	509	+	var xStrTokenizeAndFold func(string, uintptr, *[]string) []string
510			510
511		// Tokenizes @string and performs folding on each token.	511		// Tokenizes @string and performs folding on each token.
512		//	512		//

@@ -523,9 +523,9 @@ var xStrTokenizeAndFold func(string, string, *[]string) []string
523		// for doing so is unspecified, but @translit_locale (if specified) may	523		// for doing so is unspecified, but @translit_locale (if specified) may
524		// improve the transliteration if the language of the source string is	524		// improve the transliteration if the language of the source string is
525		// known.	525		// known.
526	-	func StrTokenizeAndFold(StringVar string, TranslitLocaleVar string, AsciiAlternatesVar *[]string) []string {	526	+	func StrTokenizeAndFold(StringVar string, TranslitLocaleVar string, AsciiAlternatesVar []string) []string {
527			527
528	-	cret := xStrTokenizeAndFold(StringVar, TranslitLocaleVar, AsciiAlternatesVar)	528	+	cret := xStrTokenizeAndFold(StringVar, core.NullableStringToPtr(TranslitLocaleVar), AsciiAlternatesVar)
529		return cret	529		return cret
530		}	530		}
531			531

@@ -635,7 +635,7 @@ func Strconcat(String1Var string, varArgs ...interface{}) string {
635		return cret	635		return cret
636		}	636		}
637			637
638	-	var xStrdelimit func(string, string, byte) string	638	+	var xStrdelimit func(string, uintptr, byte) string
639			639
640		// Converts any delimiter characters in @string to @new_delimiter.	640		// Converts any delimiter characters in @string to @new_delimiter.
641		//	641		//

@@ -654,9 +654,9 @@ var xStrdelimit func(string, string, byte) string
654		// …	654		// …
655		// g_free (reformatted);	655		// g_free (reformatted);
656		// ```	656		// ```
657	-	func Strdelimit(StringVar string, DelimitersVar string, NewDelimiterVar byte) string {	657	+	func Strdelimit(StringVar string, DelimitersVar *string, NewDelimiterVar byte) string {
658			658
659	-	cret := xStrdelimit(StringVar, DelimitersVar, NewDelimiterVar)	659	+	cret := xStrdelimit(StringVar, core.NullableStringToPtr(DelimitersVar), NewDelimiterVar)
660		return cret	660		return cret
661		}	661		}
662			662

@@ -669,12 +669,12 @@ func Strdown(StringVar string) string {
669		return cret	669		return cret
670		}	670		}
671			671
672	-	var xStrdup func(string) string	672	+	var xStrdup func(uintptr) string
673			673
674		// Duplicates a string. If @str is `NULL` it returns `NULL`.	674		// Duplicates a string. If @str is `NULL` it returns `NULL`.
675	-	func Strdup(StrVar string) string {	675	+	func Strdup(StrVar *string) string {
676			676
677	-	cret := xStrdup(StrVar)	677	+	cret := xStrdup(core.NullableStringToPtr(StrVar))
678		return cret	678		return cret
679		}	679		}
680			680

@@ -752,7 +752,7 @@ func Strerror(ErrnumVar int) string {
752		return cret	752		return cret
753		}	753		}
754			754
755	-	var xStrescape func(string, string) string	755	+	var xStrescape func(string, uintptr) string
756			756
757		// It replaces the following special characters in the string @source	757		// It replaces the following special characters in the string @source
758		// with their corresponding C escape sequence:	758		// with their corresponding C escape sequence:

@@ -773,9 +773,9 @@ var xStrescape func(string, string) string
773		// Characters supplied in @exceptions are not escaped.	773		// Characters supplied in @exceptions are not escaped.
774		//	774		//
775		// [func@GLib.strcompress] does the reverse conversion.	775		// [func@GLib.strcompress] does the reverse conversion.
776	-	func Strescape(SourceVar string, ExceptionsVar string) string {	776	+	func Strescape(SourceVar string, ExceptionsVar *string) string {
777			777
778	-	cret := xStrescape(SourceVar, ExceptionsVar)	778	+	cret := xStrescape(SourceVar, core.NullableStringToPtr(ExceptionsVar))
779		return cret	779		return cret
780		}	780		}
781			781

@@ -790,17 +790,17 @@ func Strfreev(StrArrayVar []string) {
790			790
791		}	791		}
792			792
793	-	var xStrjoin func(string, ...interface{}) string	793	+	var xStrjoin func(uintptr, ...interface{}) string
794			794
795		// Joins a number of strings together to form one long string, with the	795		// Joins a number of strings together to form one long string, with the
796		// optional @separator inserted between each of them.	796		// optional @separator inserted between each of them.
797	-	func Strjoin(SeparatorVar string, varArgs ...interface{}) string {	797	+	func Strjoin(SeparatorVar *string, varArgs ...interface{}) string {
798			798
799	-	cret := xStrjoin(SeparatorVar, varArgs...)	799	+	cret := xStrjoin(core.NullableStringToPtr(SeparatorVar), varArgs...)
800		return cret	800		return cret
801		}	801		}
802			802
803	-	var xStrjoinv func(string, []string) string	803	+	var xStrjoinv func(uintptr, []string) string
804			804
805		// Joins an array of strings together to form one long string, with the	805		// Joins an array of strings together to form one long string, with the
806		// optional @separator inserted between each of them.	806		// optional @separator inserted between each of them.

@@ -808,9 +808,9 @@ var xStrjoinv func(string, []string) string
808		// If @str_array has no items, the return value will be an	808		// If @str_array has no items, the return value will be an
809		// empty string. If @str_array contains a single item, @separator will not	809		// empty string. If @str_array contains a single item, @separator will not
810		// appear in the resulting string.	810		// appear in the resulting string.
811	-	func Strjoinv(SeparatorVar string, StrArrayVar []string) string {	811	+	func Strjoinv(SeparatorVar *string, StrArrayVar []string) string {
812			812
813	-	cret := xStrjoinv(SeparatorVar, StrArrayVar)	813	+	cret := xStrjoinv(core.NullableStringToPtr(SeparatorVar), StrArrayVar)
814		return cret	814		return cret
815		}	815		}
816			816

@@ -869,7 +869,7 @@ func Strncasecmp(S1Var string, S2Var string, NVar uint) int {
869		return cret	869		return cret
870		}	870		}
871			871
872	-	var xStrndup func(string, uint) string	872	+	var xStrndup func(uintptr, uint) string
873			873
874		// Duplicates the first @n bytes of a string, returning a newly-allocated	874		// Duplicates the first @n bytes of a string, returning a newly-allocated
875		// buffer @n + 1 bytes long which will always be nul-terminated. If @str	875		// buffer @n + 1 bytes long which will always be nul-terminated. If @str

@@ -878,9 +878,9 @@ var xStrndup func(string, uint) string
878		//	878		//
879		// To copy a number of characters from a UTF-8 encoded string,	879		// To copy a number of characters from a UTF-8 encoded string,
880		// use [func@GLib.utf8_strncpy] instead.	880		// use [func@GLib.utf8_strncpy] instead.
881	-	func Strndup(StrVar string, NVar uint) string {	881	+	func Strndup(StrVar *string, NVar uint) string {
882			882
883	-	cret := xStrndup(StrVar, NVar)	883	+	cret := xStrndup(core.NullableStringToPtr(StrVar), NVar)
884		return cret	884		return cret
885		}	885		}
886			886

M v4/glib/gstring.go +6 -6


@@ -40,12 +40,12 @@ func (x *String) GoPointer() uintptr {
40		return uintptr(unsafe.Pointer(x))	40		return uintptr(unsafe.Pointer(x))
41		}	41		}
42			42
43	-	var xNewString func(string) *String	43	+	var xNewString func(uintptr) *String
44			44
45		// Creates a new #GString, initialized with the given string.	45		// Creates a new #GString, initialized with the given string.
46	-	func NewString(InitVar string) *String {	46	+	func NewString(InitVar string) String {
47			47
48	-	cret := xNewString(InitVar)	48	+	cret := xNewString(core.NullableStringToPtr(InitVar))
49		return cret	49		return cret
50		}	50		}
51			51

@@ -64,16 +64,16 @@ func NewStringLen(InitVar string, LenVar int) *String {
64		return cret	64		return cret
65		}	65		}
66			66
67	-	var xNewStringTake func(string) *String	67	+	var xNewStringTake func(uintptr) *String
68			68
69		// Creates a new #GString, initialized with the given string.	69		// Creates a new #GString, initialized with the given string.
70		//	70		//
71		// After this call, @init belongs to the #GString and may no longer be	71		// After this call, @init belongs to the #GString and may no longer be
72		// modified by the caller. The memory of @init has to be dynamically	72		// modified by the caller. The memory of @init has to be dynamically
73		// allocated and will eventually be freed with g_free().	73		// allocated and will eventually be freed with g_free().
74	-	func NewStringTake(InitVar string) *String {	74	+	func NewStringTake(InitVar string) String {
75			75
76	-	cret := xNewStringTake(InitVar)	76	+	cret := xNewStringTake(core.NullableStringToPtr(InitVar))
77		return cret	77		return cret
78		}	78		}
79			79

M v4/glib/gtestutils.go +208 -28


@@ -379,25 +379,25 @@ func AssertionMessageError(DomainVar string, FileVar string, LineVar int, FuncVa
379			379
380		}	380		}
381			381
382	-	var xAssertionMessageExpr func(string, string, int, string, string)	382	+	var xAssertionMessageExpr func(uintptr, string, int, string, uintptr)
383			383
384		// Internal function used to print messages from the public	384		// Internal function used to print messages from the public
385		// g_assert() and g_assert_not_reached() macros.	385		// g_assert() and g_assert_not_reached() macros.
386	-	func AssertionMessageExpr(DomainVar string, FileVar string, LineVar int, FuncVar string, ExprVar string) {	386	+	func AssertionMessageExpr(DomainVar string, FileVar string, LineVar int, FuncVar string, ExprVar string) {
387			387
388	-	xAssertionMessageExpr(DomainVar, FileVar, LineVar, FuncVar, ExprVar)	388	+	xAssertionMessageExpr(core.NullableStringToPtr(DomainVar), FileVar, LineVar, FuncVar, core.NullableStringToPtr(ExprVar))
389			389
390		}	390		}
391			391
392	-	var xStrcmp0 func(string, string) int	392	+	var xStrcmp0 func(uintptr, uintptr) int
393			393
394		// Compares @str1 and @str2 like `strcmp()`.	394		// Compares @str1 and @str2 like `strcmp()`.
395		//	395		//
396		// Handles `NULL` gracefully by sorting it before non-`NULL` strings.	396		// Handles `NULL` gracefully by sorting it before non-`NULL` strings.
397		// Comparing two `NULL` pointers returns 0.	397		// Comparing two `NULL` pointers returns 0.
398	-	func Strcmp0(Str1Var string, Str2Var string) int {	398	+	func Strcmp0(Str1Var string, Str2Var string) int {
399			399
400	-	cret := xStrcmp0(Str1Var, Str2Var)	400	+	cret := xStrcmp0(core.NullableStringToPtr(Str1Var), core.NullableStringToPtr(Str2Var))
401		return cret	401		return cret
402		}	402		}
403			403

@@ -420,7 +420,22 @@ var xTestAddDataFunc func(string, uintptr, uintptr)
420		// and it is recommended to do so even if it isn’t.	420		// and it is recommended to do so even if it isn’t.
421		func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {	421		func TestAddDataFunc(TestpathVar string, TestDataVar uintptr, TestFuncVar *TestDataFunc) {
422			422
423	-	xTestAddDataFunc(TestpathVar, TestDataVar, NewCallback(TestFuncVar))	423	+	var TestFuncVarRef uintptr
			424	+	if TestFuncVar != nil {
			425	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
			426	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
			427	+	TestFuncVarRef = cbRefPtr
			428	+	} else {
			429	+	fcb := func(arg0 uintptr) {
			430	+	cbFn := *TestFuncVar
			431	+	cbFn(arg0)
			432	+	}
			433	+	TestFuncVarRef = purego.NewCallback(fcb)
			434	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
			435	+	}
			436	+	}
			437	+
			438	+	xTestAddDataFunc(TestpathVar, TestDataVar, TestFuncVarRef)
424			439
425		}	440		}
426			441

@@ -432,7 +447,37 @@ var xTestAddDataFuncFull func(string, uintptr, uintptr, uintptr)
432		// is freeing @test_data after the test run is complete.	447		// is freeing @test_data after the test run is complete.
433		func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc, DataFreeFuncVar DestroyNotify) {	448		func TestAddDataFuncFull(TestpathVar string, TestDataVar uintptr, TestFuncVar TestDataFunc, DataFreeFuncVar DestroyNotify) {
434			449
435	-	xTestAddDataFuncFull(TestpathVar, TestDataVar, NewCallback(TestFuncVar), NewCallback(DataFreeFuncVar))	450	+	var TestFuncVarRef uintptr
			451	+	if TestFuncVar != nil {
			452	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
			453	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
			454	+	TestFuncVarRef = cbRefPtr
			455	+	} else {
			456	+	fcb := func(arg0 uintptr) {
			457	+	cbFn := *TestFuncVar
			458	+	cbFn(arg0)
			459	+	}
			460	+	TestFuncVarRef = purego.NewCallback(fcb)
			461	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
			462	+	}
			463	+	}
			464	+
			465	+	var DataFreeFuncVarRef uintptr
			466	+	if DataFreeFuncVar != nil {
			467	+	DataFreeFuncVarPtr := uintptr(unsafe.Pointer(DataFreeFuncVar))
			468	+	if cbRefPtr, ok := GetCallback(DataFreeFuncVarPtr); ok {
			469	+	DataFreeFuncVarRef = cbRefPtr
			470	+	} else {
			471	+	fcb := func(arg0 uintptr) {
			472	+	cbFn := *DataFreeFuncVar
			473	+	cbFn(arg0)
			474	+	}
			475	+	DataFreeFuncVarRef = purego.NewCallback(fcb)
			476	+	SaveCallback(DataFreeFuncVarPtr, DataFreeFuncVarRef)
			477	+	}
			478	+	}
			479	+
			480	+	xTestAddDataFuncFull(TestpathVar, TestDataVar, TestFuncVarRef, DataFreeFuncVarRef)
436			481
437		}	482		}
438			483

@@ -454,7 +499,22 @@ var xTestAddFunc func(string, uintptr)
454		// it is recommended to do so even if it isn’t.	499		// it is recommended to do so even if it isn’t.
455		func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {	500		func TestAddFunc(TestpathVar string, TestFuncVar *TestFunc) {
456			501
457	-	xTestAddFunc(TestpathVar, NewCallback(TestFuncVar))	502	+	var TestFuncVarRef uintptr
			503	+	if TestFuncVar != nil {
			504	+	TestFuncVarPtr := uintptr(unsafe.Pointer(TestFuncVar))
			505	+	if cbRefPtr, ok := GetCallback(TestFuncVarPtr); ok {
			506	+	TestFuncVarRef = cbRefPtr
			507	+	} else {
			508	+	fcb := func() {
			509	+	cbFn := *TestFuncVar
			510	+	cbFn()
			511	+	}
			512	+	TestFuncVarRef = purego.NewCallback(fcb)
			513	+	SaveCallback(TestFuncVarPtr, TestFuncVarRef)
			514	+	}
			515	+	}
			516	+
			517	+	xTestAddFunc(TestpathVar, TestFuncVarRef)
458			518
459		}	519		}
460			520

@@ -462,7 +522,52 @@ var xTestAddVtable func(string, uint, uintptr, uintptr, uintptr, uintptr)
462			522
463		func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {	523		func TestAddVtable(TestpathVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar *TestFixtureFunc) {
464			524
465	-	xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))	525	+	var DataSetupVarRef uintptr
			526	+	if DataSetupVar != nil {
			527	+	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
			528	+	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
			529	+	DataSetupVarRef = cbRefPtr
			530	+	} else {
			531	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			532	+	cbFn := *DataSetupVar
			533	+	cbFn(arg0, arg1)
			534	+	}
			535	+	DataSetupVarRef = purego.NewCallback(fcb)
			536	+	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
			537	+	}
			538	+	}
			539	+
			540	+	var DataTestVarRef uintptr
			541	+	if DataTestVar != nil {
			542	+	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
			543	+	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
			544	+	DataTestVarRef = cbRefPtr
			545	+	} else {
			546	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			547	+	cbFn := *DataTestVar
			548	+	cbFn(arg0, arg1)
			549	+	}
			550	+	DataTestVarRef = purego.NewCallback(fcb)
			551	+	SaveCallback(DataTestVarPtr, DataTestVarRef)
			552	+	}
			553	+	}
			554	+
			555	+	var DataTeardownVarRef uintptr
			556	+	if DataTeardownVar != nil {
			557	+	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
			558	+	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
			559	+	DataTeardownVarRef = cbRefPtr
			560	+	} else {
			561	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			562	+	cbFn := *DataTeardownVar
			563	+	cbFn(arg0, arg1)
			564	+	}
			565	+	DataTeardownVarRef = purego.NewCallback(fcb)
			566	+	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
			567	+	}
			568	+	}
			569	+
			570	+	xTestAddVtable(TestpathVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
466			571
467		}	572		}
468			573

@@ -566,7 +671,52 @@ var xTestCreateCase func(string, uint, uintptr, uintptr, uintptr, uintptr) *Test
566		// varying @test_name and @data_test arguments.	671		// varying @test_name and @data_test arguments.
567		func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) TestCase {	672		func TestCreateCase(TestNameVar string, DataSizeVar uint, TestDataVar uintptr, DataSetupVar TestFixtureFunc, DataTestVar TestFixtureFunc, DataTeardownVar TestFixtureFunc) TestCase {
568			673
569	-	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, NewCallback(DataSetupVar), NewCallback(DataTestVar), NewCallback(DataTeardownVar))	674	+	var DataSetupVarRef uintptr
			675	+	if DataSetupVar != nil {
			676	+	DataSetupVarPtr := uintptr(unsafe.Pointer(DataSetupVar))
			677	+	if cbRefPtr, ok := GetCallback(DataSetupVarPtr); ok {
			678	+	DataSetupVarRef = cbRefPtr
			679	+	} else {
			680	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			681	+	cbFn := *DataSetupVar
			682	+	cbFn(arg0, arg1)
			683	+	}
			684	+	DataSetupVarRef = purego.NewCallback(fcb)
			685	+	SaveCallback(DataSetupVarPtr, DataSetupVarRef)
			686	+	}
			687	+	}
			688	+
			689	+	var DataTestVarRef uintptr
			690	+	if DataTestVar != nil {
			691	+	DataTestVarPtr := uintptr(unsafe.Pointer(DataTestVar))
			692	+	if cbRefPtr, ok := GetCallback(DataTestVarPtr); ok {
			693	+	DataTestVarRef = cbRefPtr
			694	+	} else {
			695	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			696	+	cbFn := *DataTestVar
			697	+	cbFn(arg0, arg1)
			698	+	}
			699	+	DataTestVarRef = purego.NewCallback(fcb)
			700	+	SaveCallback(DataTestVarPtr, DataTestVarRef)
			701	+	}
			702	+	}
			703	+
			704	+	var DataTeardownVarRef uintptr
			705	+	if DataTeardownVar != nil {
			706	+	DataTeardownVarPtr := uintptr(unsafe.Pointer(DataTeardownVar))
			707	+	if cbRefPtr, ok := GetCallback(DataTeardownVarPtr); ok {
			708	+	DataTeardownVarRef = cbRefPtr
			709	+	} else {
			710	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			711	+	cbFn := *DataTeardownVar
			712	+	cbFn(arg0, arg1)
			713	+	}
			714	+	DataTeardownVarRef = purego.NewCallback(fcb)
			715	+	SaveCallback(DataTeardownVarPtr, DataTeardownVarRef)
			716	+	}
			717	+	}
			718	+
			719	+	cret := xTestCreateCase(TestNameVar, DataSizeVar, TestDataVar, DataSetupVarRef, DataTestVarRef, DataTeardownVarRef)
570		return cret	720		return cret
571		}	721		}
572			722

@@ -592,7 +742,7 @@ func TestDisableCrashReporting() {
592			742
593		}	743		}
594			744
595	-	var xTestExpectMessage func(string, LogLevelFlags, string)	745	+	var xTestExpectMessage func(uintptr, LogLevelFlags, string)
596			746
597		// Indicates that a message with the given @log_domain and @log_level,	747		// Indicates that a message with the given @log_domain and @log_level,
598		// with text matching @pattern, is expected to be logged.	748		// with text matching @pattern, is expected to be logged.

@@ -631,9 +781,9 @@ var xTestExpectMessage func(string, LogLevelFlags, string)
631		//	781		//
632		// If messages at [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly	782		// If messages at [flags@GLib.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly
633		// expected via [func@GLib.test_expect_message] then they will be ignored.	783		// expected via [func@GLib.test_expect_message] then they will be ignored.
634	-	func TestExpectMessage(LogDomainVar string, LogLevelVar LogLevelFlags, PatternVar string) {	784	+	func TestExpectMessage(LogDomainVar *string, LogLevelVar LogLevelFlags, PatternVar string) {
635			785
636	-	xTestExpectMessage(LogDomainVar, LogLevelVar, PatternVar)	786	+	xTestExpectMessage(core.NullableStringToPtr(LogDomainVar), LogLevelVar, PatternVar)
637			787
638		}	788		}
639			789

@@ -755,7 +905,7 @@ func TestGetRoot() *TestSuite {
755		return cret	905		return cret
756		}	906		}
757			907
758	-	var xTestIncomplete func(string)	908	+	var xTestIncomplete func(uintptr)
759			909
760		// Indicates that a test failed because of some incomplete	910		// Indicates that a test failed because of some incomplete
761		// functionality.	911		// functionality.

@@ -768,9 +918,9 @@ var xTestIncomplete func(string)
768		// the test.	918		// the test.
769		//	919		//
770		// If not called from inside a test, this function does nothing.	920		// If not called from inside a test, this function does nothing.
771	-	func TestIncomplete(MsgVar string) {	921	+	func TestIncomplete(MsgVar *string) {
772			922
773	-	xTestIncomplete(MsgVar)	923	+	xTestIncomplete(core.NullableStringToPtr(MsgVar))
774			924
775		}	925		}
776			926

@@ -879,7 +1029,22 @@ var xTestLogSetFatalHandler func(uintptr, uintptr)
879		// [Using Structured Logging](logging.html#using-structured-logging).	1029		// [Using Structured Logging](logging.html#using-structured-logging).
880		func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {	1030		func TestLogSetFatalHandler(LogFuncVar *TestLogFatalFunc, UserDataVar uintptr) {
881			1031
882	-	xTestLogSetFatalHandler(NewCallback(LogFuncVar), UserDataVar)	1032	+	var LogFuncVarRef uintptr
			1033	+	if LogFuncVar != nil {
			1034	+	LogFuncVarPtr := uintptr(unsafe.Pointer(LogFuncVar))
			1035	+	if cbRefPtr, ok := GetCallback(LogFuncVarPtr); ok {
			1036	+	LogFuncVarRef = cbRefPtr
			1037	+	} else {
			1038	+	fcb := func(arg0 string, arg1 LogLevelFlags, arg2 string, arg3 uintptr) bool {
			1039	+	cbFn := *LogFuncVar
			1040	+	return cbFn(arg0, arg1, arg2, arg3)
			1041	+	}
			1042	+	LogFuncVarRef = purego.NewCallback(fcb)
			1043	+	SaveCallback(LogFuncVarPtr, LogFuncVarRef)
			1044	+	}
			1045	+	}
			1046	+
			1047	+	xTestLogSetFatalHandler(LogFuncVarRef, UserDataVar)
883			1048
884		}	1049		}
885			1050

@@ -939,7 +1104,22 @@ var xTestQueueDestroy func(uintptr, uintptr)
939		// before `A()` during teardown.	1104		// before `A()` during teardown.
940		func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {	1105		func TestQueueDestroy(DestroyFuncVar *DestroyNotify, DestroyDataVar uintptr) {
941			1106
942	-	xTestQueueDestroy(NewCallback(DestroyFuncVar), DestroyDataVar)	1107	+	var DestroyFuncVarRef uintptr
			1108	+	if DestroyFuncVar != nil {
			1109	+	DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
			1110	+	if cbRefPtr, ok := GetCallback(DestroyFuncVarPtr); ok {
			1111	+	DestroyFuncVarRef = cbRefPtr
			1112	+	} else {
			1113	+	fcb := func(arg0 uintptr) {
			1114	+	cbFn := *DestroyFuncVar
			1115	+	cbFn(arg0)
			1116	+	}
			1117	+	DestroyFuncVarRef = purego.NewCallback(fcb)
			1118	+	SaveCallback(DestroyFuncVarPtr, DestroyFuncVarRef)
			1119	+	}
			1120	+	}
			1121	+
			1122	+	xTestQueueDestroy(DestroyFuncVarRef, DestroyDataVar)
943			1123
944		}	1124		}
945			1125

@@ -1088,7 +1268,7 @@ func TestSetNonfatalAssertions() {
1088			1268
1089		}	1269		}
1090			1270
1091	-	var xTestSkip func(string)	1271	+	var xTestSkip func(uintptr)
1092			1272
1093		// Indicates that a test was skipped.	1273		// Indicates that a test was skipped.
1094		//	1274		//

@@ -1098,9 +1278,9 @@ var xTestSkip func(string)
1098		// the test.	1278		// the test.
1099		//	1279		//
1100		// If not called from inside a test, this function does nothing.	1280		// If not called from inside a test, this function does nothing.
1101	-	func TestSkip(MsgVar string) {	1281	+	func TestSkip(MsgVar *string) {
1102			1282
1103	-	xTestSkip(MsgVar)	1283	+	xTestSkip(core.NullableStringToPtr(MsgVar))
1104			1284
1105		}	1285		}
1106			1286

@@ -1259,20 +1439,20 @@ func TestTrapReachedTimeout() bool {
1259		return cret	1439		return cret
1260		}	1440		}
1261			1441
1262	-	var xTestTrapSubprocess func(string, uint64, TestSubprocessFlags)	1442	+	var xTestTrapSubprocess func(uintptr, uint64, TestSubprocessFlags)
1263			1443
1264		// Respawns the test program to run only @test_path in a subprocess.	1444		// Respawns the test program to run only @test_path in a subprocess.
1265		//	1445		//
1266		// This is equivalent to calling [func@GLib.test_trap_subprocess_with_envp]	1446		// This is equivalent to calling [func@GLib.test_trap_subprocess_with_envp]
1267		// with `envp` set to `NULL`. See the documentation for that function	1447		// with `envp` set to `NULL`. See the documentation for that function
1268		// for full details.	1448		// for full details.
1269	-	func TestTrapSubprocess(TestPathVar string, UsecTimeoutVar uint64, TestFlagsVar TestSubprocessFlags) {	1449	+	func TestTrapSubprocess(TestPathVar *string, UsecTimeoutVar uint64, TestFlagsVar TestSubprocessFlags) {
1270			1450
1271	-	xTestTrapSubprocess(TestPathVar, UsecTimeoutVar, TestFlagsVar)	1451	+	xTestTrapSubprocess(core.NullableStringToPtr(TestPathVar), UsecTimeoutVar, TestFlagsVar)
1272			1452
1273		}	1453		}
1274			1454
1275	-	var xTestTrapSubprocessWithEnvp func(string, []string, uint64, TestSubprocessFlags)	1455	+	var xTestTrapSubprocessWithEnvp func(uintptr, []string, uint64, TestSubprocessFlags)
1276			1456
1277		// Respawns the test program to run only @test_path in a subprocess with	1457		// Respawns the test program to run only @test_path in a subprocess with
1278		// a given environment.	1458		// a given environment.

@@ -1365,9 +1545,9 @@ var xTestTrapSubprocessWithEnvp func(string, []string, uint64, TestSubprocessFla
1365		// }	1545		// }
1366		//	1546		//
1367		// ```	1547		// ```
1368	-	func TestTrapSubprocessWithEnvp(TestPathVar string, EnvpVar []string, UsecTimeoutVar uint64, TestFlagsVar TestSubprocessFlags) {	1548	+	func TestTrapSubprocessWithEnvp(TestPathVar *string, EnvpVar []string, UsecTimeoutVar uint64, TestFlagsVar TestSubprocessFlags) {
1369			1549
1370	-	xTestTrapSubprocessWithEnvp(TestPathVar, EnvpVar, UsecTimeoutVar, TestFlagsVar)	1550	+	xTestTrapSubprocessWithEnvp(core.NullableStringToPtr(TestPathVar), EnvpVar, UsecTimeoutVar, TestFlagsVar)
1371			1551
1372		}	1552		}
1373			1553

M v4/glib/gthread.go +132 -12


@@ -281,7 +281,22 @@ var xOnceImpl func(uintptr, uintptr, uintptr) uintptr
281			281
282		func (x Once) Impl(FuncVar ThreadFunc, ArgVar uintptr) uintptr {	282		func (x Once) Impl(FuncVar ThreadFunc, ArgVar uintptr) uintptr {
283			283
284	-	cret := xOnceImpl(x.GoPointer(), NewCallback(FuncVar), ArgVar)	284	+	var FuncVarRef uintptr
			285	+	if FuncVar != nil {
			286	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			287	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			288	+	FuncVarRef = cbRefPtr
			289	+	} else {
			290	+	fcb := func(arg0 uintptr) uintptr {
			291	+	cbFn := *FuncVar
			292	+	return cbFn(arg0)
			293	+	}
			294	+	FuncVarRef = purego.NewCallback(fcb)
			295	+	SaveCallback(FuncVarPtr, FuncVarRef)
			296	+	}
			297	+	}
			298	+
			299	+	cret := xOnceImpl(x.GoPointer(), FuncVarRef, ArgVar)
285		return cret	300		return cret
286		}	301		}
287			302

@@ -859,7 +874,22 @@ var xStaticPrivateSet func(uintptr, uintptr, uintptr)
859		// @notify is used quite differently from @destructor in g_private_new().	874		// @notify is used quite differently from @destructor in g_private_new().
860		func (x StaticPrivate) Set(DataVar uintptr, NotifyVar DestroyNotify) {	875		func (x StaticPrivate) Set(DataVar uintptr, NotifyVar DestroyNotify) {
861			876
862	-	xStaticPrivateSet(x.GoPointer(), DataVar, NewCallback(NotifyVar))	877	+	var NotifyVarRef uintptr
			878	+	if NotifyVar != nil {
			879	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			880	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			881	+	NotifyVarRef = cbRefPtr
			882	+	} else {
			883	+	fcb := func(arg0 uintptr) {
			884	+	cbFn := *NotifyVar
			885	+	cbFn(arg0)
			886	+	}
			887	+	NotifyVarRef = purego.NewCallback(fcb)
			888	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			889	+	}
			890	+	}
			891	+
			892	+	xStaticPrivateSet(x.GoPointer(), DataVar, NotifyVarRef)
863			893
864		}	894		}
865			895

@@ -1219,7 +1249,7 @@ func (x *Thread) GoPointer() uintptr {
1219		return uintptr(unsafe.Pointer(x))	1249		return uintptr(unsafe.Pointer(x))
1220		}	1250		}
1221			1251
1222	-	var xNewThread func(string, uintptr, uintptr) *Thread	1252	+	var xNewThread func(uintptr, uintptr, uintptr) *Thread
1223			1253
1224		// This function creates a new thread. The new thread starts by invoking	1254		// This function creates a new thread. The new thread starts by invoking
1225		// @func with the argument data. The thread will run until @func returns	1255		// @func with the argument data. The thread will run until @func returns

@@ -1248,23 +1278,53 @@ var xNewThread func(string, uintptr, uintptr) *Thread
1248		// inheriting the thread priority but were spawned with the default priority.	1278		// inheriting the thread priority but were spawned with the default priority.
1249		// Starting with GLib 2.64 the behaviour is now consistent between Windows and	1279		// Starting with GLib 2.64 the behaviour is now consistent between Windows and
1250		// POSIX and all threads inherit their parent thread's priority.	1280		// POSIX and all threads inherit their parent thread's priority.
1251	-	func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) Thread {	1281	+	func NewThread(NameVar string, FuncVar ThreadFunc, DataVar uintptr) *Thread {
			1282	+
			1283	+	var FuncVarRef uintptr
			1284	+	if FuncVar != nil {
			1285	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			1286	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			1287	+	FuncVarRef = cbRefPtr
			1288	+	} else {
			1289	+	fcb := func(arg0 uintptr) uintptr {
			1290	+	cbFn := *FuncVar
			1291	+	return cbFn(arg0)
			1292	+	}
			1293	+	FuncVarRef = purego.NewCallback(fcb)
			1294	+	SaveCallback(FuncVarPtr, FuncVarRef)
			1295	+	}
			1296	+	}
1252			1297
1253	-	cret := xNewThread(NameVar, NewCallback(FuncVar), DataVar)	1298	+	cret := xNewThread(core.NullableStringToPtr(NameVar), FuncVarRef, DataVar)
1254		return cret	1299		return cret
1255		}	1300		}
1256			1301
1257	-	var xThreadTryNew func(string, uintptr, uintptr, *Error) Thread	1302	+	var xThreadTryNew func(uintptr, uintptr, uintptr, *Error) Thread
1258			1303
1259		// This function is the same as g_thread_new() except that	1304		// This function is the same as g_thread_new() except that
1260		// it allows for the possibility of failure.	1305		// it allows for the possibility of failure.
1261		//	1306		//
1262		// If a thread can not be created (due to resource limits),	1307		// If a thread can not be created (due to resource limits),
1263		// @error is set and %NULL is returned.	1308		// @error is set and %NULL is returned.
1264	-	func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (Thread, error) {	1309	+	func ThreadTryNew(NameVar string, FuncVar ThreadFunc, DataVar uintptr) (*Thread, error) {
1265		var cerr *Error	1310		var cerr *Error
1266			1311
1267	-	cret := xThreadTryNew(NameVar, NewCallback(FuncVar), DataVar, &cerr)	1312	+	var FuncVarRef uintptr
			1313	+	if FuncVar != nil {
			1314	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			1315	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			1316	+	FuncVarRef = cbRefPtr
			1317	+	} else {
			1318	+	fcb := func(arg0 uintptr) uintptr {
			1319	+	cbFn := *FuncVar
			1320	+	return cbFn(arg0)
			1321	+	}
			1322	+	FuncVarRef = purego.NewCallback(fcb)
			1323	+	SaveCallback(FuncVarPtr, FuncVarRef)
			1324	+	}
			1325	+	}
			1326	+
			1327	+	cret := xThreadTryNew(core.NullableStringToPtr(NameVar), FuncVarRef, DataVar, &cerr)
1268		if cerr == nil {	1328		if cerr == nil {
1269		return cret, nil	1329		return cret, nil
1270		}	1330		}

@@ -2160,7 +2220,22 @@ var xPrivateNew func(uintptr) *Private
2160		// Creates a new #GPrivate.	2220		// Creates a new #GPrivate.
2161		func PrivateNew(NotifyVar DestroyNotify) Private {	2221		func PrivateNew(NotifyVar DestroyNotify) Private {
2162			2222
2163	-	cret := xPrivateNew(NewCallback(NotifyVar))	2223	+	var NotifyVarRef uintptr
			2224	+	if NotifyVar != nil {
			2225	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			2226	+	if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
			2227	+	NotifyVarRef = cbRefPtr
			2228	+	} else {
			2229	+	fcb := func(arg0 uintptr) {
			2230	+	cbFn := *NotifyVar
			2231	+	cbFn(arg0)
			2232	+	}
			2233	+	NotifyVarRef = purego.NewCallback(fcb)
			2234	+	SaveCallback(NotifyVarPtr, NotifyVarRef)
			2235	+	}
			2236	+	}
			2237	+
			2238	+	cret := xPrivateNew(NotifyVarRef)
2164		return cret	2239		return cret
2165		}	2240		}
2166			2241

@@ -2181,7 +2256,22 @@ var xThreadCreate func(uintptr, uintptr, bool, *Error) Thread
2181		func ThreadCreate(FuncVar ThreadFunc, DataVar uintptr, JoinableVar bool) (Thread, error) {	2256		func ThreadCreate(FuncVar ThreadFunc, DataVar uintptr, JoinableVar bool) (Thread, error) {
2182		var cerr *Error	2257		var cerr *Error
2183			2258
2184	-	cret := xThreadCreate(NewCallback(FuncVar), DataVar, JoinableVar, &cerr)	2259	+	var FuncVarRef uintptr
			2260	+	if FuncVar != nil {
			2261	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			2262	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			2263	+	FuncVarRef = cbRefPtr
			2264	+	} else {
			2265	+	fcb := func(arg0 uintptr) uintptr {
			2266	+	cbFn := *FuncVar
			2267	+	return cbFn(arg0)
			2268	+	}
			2269	+	FuncVarRef = purego.NewCallback(fcb)
			2270	+	SaveCallback(FuncVarPtr, FuncVarRef)
			2271	+	}
			2272	+	}
			2273	+
			2274	+	cret := xThreadCreate(FuncVarRef, DataVar, JoinableVar, &cerr)
2185		if cerr == nil {	2275		if cerr == nil {
2186		return cret, nil	2276		return cret, nil
2187		}	2277		}

@@ -2195,7 +2285,22 @@ var xThreadCreateFull func(uintptr, uintptr, uint32, bool, bool, ThreadPriority,
2195		func ThreadCreateFull(FuncVar ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (Thread, error) {	2285		func ThreadCreateFull(FuncVar ThreadFunc, DataVar uintptr, StackSizeVar uint32, JoinableVar bool, BoundVar bool, PriorityVar ThreadPriority) (Thread, error) {
2196		var cerr *Error	2286		var cerr *Error
2197			2287
2198	-	cret := xThreadCreateFull(NewCallback(FuncVar), DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)	2288	+	var FuncVarRef uintptr
			2289	+	if FuncVar != nil {
			2290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			2291	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			2292	+	FuncVarRef = cbRefPtr
			2293	+	} else {
			2294	+	fcb := func(arg0 uintptr) uintptr {
			2295	+	cbFn := *FuncVar
			2296	+	return cbFn(arg0)
			2297	+	}
			2298	+	FuncVarRef = purego.NewCallback(fcb)
			2299	+	SaveCallback(FuncVarPtr, FuncVarRef)
			2300	+	}
			2301	+	}
			2302	+
			2303	+	cret := xThreadCreateFull(FuncVarRef, DataVar, StackSizeVar, JoinableVar, BoundVar, PriorityVar, &cerr)
2199		if cerr == nil {	2304		if cerr == nil {
2200		return cret, nil	2305		return cret, nil
2201		}	2306		}

@@ -2239,7 +2344,22 @@ var xThreadForeach func(uintptr, uintptr)
2239		// which is quadratic in the number of existing threads.	2344		// which is quadratic in the number of existing threads.
2240		func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {	2345		func ThreadForeach(ThreadFuncVar *Func, UserDataVar uintptr) {
2241			2346
2242	-	xThreadForeach(NewCallback(ThreadFuncVar), UserDataVar)	2347	+	var ThreadFuncVarRef uintptr
			2348	+	if ThreadFuncVar != nil {
			2349	+	ThreadFuncVarPtr := uintptr(unsafe.Pointer(ThreadFuncVar))
			2350	+	if cbRefPtr, ok := GetCallback(ThreadFuncVarPtr); ok {
			2351	+	ThreadFuncVarRef = cbRefPtr
			2352	+	} else {
			2353	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			2354	+	cbFn := *ThreadFuncVar
			2355	+	cbFn(arg0, arg1)
			2356	+	}
			2357	+	ThreadFuncVarRef = purego.NewCallback(fcb)
			2358	+	SaveCallback(ThreadFuncVarPtr, ThreadFuncVarRef)
			2359	+	}
			2360	+	}
			2361	+
			2362	+	xThreadForeach(ThreadFuncVarRef, UserDataVar)
2243			2363
2244		}	2364		}
2245			2365

M v4/glib/gthreadpool.go +16 -1


@@ -172,7 +172,22 @@ var xThreadPoolSetSortFunction func(uintptr, uintptr, uintptr)
172		// created.	172		// created.
173		func (x ThreadPool) SetSortFunction(FuncVar CompareDataFunc, UserDataVar uintptr) {	173		func (x ThreadPool) SetSortFunction(FuncVar CompareDataFunc, UserDataVar uintptr) {
174			174
175	-	xThreadPoolSetSortFunction(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	175	+	var FuncVarRef uintptr
			176	+	if FuncVar != nil {
			177	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			178	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			179	+	FuncVarRef = cbRefPtr
			180	+	} else {
			181	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			182	+	cbFn := *FuncVar
			183	+	return cbFn(arg0, arg1, arg2)
			184	+	}
			185	+	FuncVarRef = purego.NewCallback(fcb)
			186	+	SaveCallback(FuncVarPtr, FuncVarRef)
			187	+	}
			188	+	}
			189	+
			190	+	xThreadPoolSetSortFunction(x.GoPointer(), FuncVarRef, UserDataVar)
176			191
177		}	192		}
178			193

M v4/glib/gtimezone.go +6 -6


@@ -50,20 +50,20 @@ func (x *TimeZone) GoPointer() uintptr {
50		return uintptr(unsafe.Pointer(x))	50		return uintptr(unsafe.Pointer(x))
51		}	51		}
52			52
53	-	var xNewTimeZone func(string) *TimeZone	53	+	var xNewTimeZone func(uintptr) *TimeZone
54			54
55		// A version of g_time_zone_new_identifier() which returns the UTC time zone	55		// A version of g_time_zone_new_identifier() which returns the UTC time zone
56		// if @identifier could not be parsed or loaded.	56		// if @identifier could not be parsed or loaded.
57		//	57		//
58		// If you need to check whether @identifier was loaded successfully, use	58		// If you need to check whether @identifier was loaded successfully, use
59		// g_time_zone_new_identifier().	59		// g_time_zone_new_identifier().
60	-	func NewTimeZone(IdentifierVar string) *TimeZone {	60	+	func NewTimeZone(IdentifierVar string) TimeZone {
61			61
62	-	cret := xNewTimeZone(IdentifierVar)	62	+	cret := xNewTimeZone(core.NullableStringToPtr(IdentifierVar))
63		return cret	63		return cret
64		}	64		}
65			65
66	-	var xNewTimeZoneIdentifier func(string) *TimeZone	66	+	var xNewTimeZoneIdentifier func(uintptr) *TimeZone
67			67
68		// Creates a #GTimeZone corresponding to @identifier. If @identifier cannot be	68		// Creates a #GTimeZone corresponding to @identifier. If @identifier cannot be
69		// parsed or loaded, %NULL is returned.	69		// parsed or loaded, %NULL is returned.

@@ -130,9 +130,9 @@ var xNewTimeZoneIdentifier func(string) *TimeZone
130		//	130		//
131		// You should release the return value by calling g_time_zone_unref()	131		// You should release the return value by calling g_time_zone_unref()
132		// when you are done with it.	132		// when you are done with it.
133	-	func NewTimeZoneIdentifier(IdentifierVar string) *TimeZone {	133	+	func NewTimeZoneIdentifier(IdentifierVar string) TimeZone {
134			134
135	-	cret := xNewTimeZoneIdentifier(IdentifierVar)	135	+	cret := xNewTimeZoneIdentifier(core.NullableStringToPtr(IdentifierVar))
136		return cret	136		return cret
137		}	137		}
138			138

M v4/glib/gtree.go +158 -8


@@ -44,7 +44,22 @@ var xNewTree func(uintptr) *Tree
44		// Creates a new #GTree.	44		// Creates a new #GTree.
45		func NewTree(KeyCompareFuncVar CompareFunc) Tree {	45		func NewTree(KeyCompareFuncVar CompareFunc) Tree {
46			46
47	-	cret := xNewTree(NewCallback(KeyCompareFuncVar))	47	+	var KeyCompareFuncVarRef uintptr
			48	+	if KeyCompareFuncVar != nil {
			49	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
			50	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
			51	+	KeyCompareFuncVarRef = cbRefPtr
			52	+	} else {
			53	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			54	+	cbFn := *KeyCompareFuncVar
			55	+	return cbFn(arg0, arg1)
			56	+	}
			57	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
			58	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
			59	+	}
			60	+	}
			61	+
			62	+	cret := xNewTree(KeyCompareFuncVarRef)
48		return cret	63		return cret
49		}	64		}
50			65

@@ -55,7 +70,52 @@ var xNewTreeFull func(uintptr, uintptr, uintptr, uintptr) *Tree
55		// removing the entry from the #GTree.	70		// removing the entry from the #GTree.
56		func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) Tree {	71		func NewTreeFull(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr, KeyDestroyFuncVar DestroyNotify, ValueDestroyFuncVar DestroyNotify) Tree {
57			72
58	-	cret := xNewTreeFull(NewCallback(KeyCompareFuncVar), KeyCompareDataVar, NewCallback(KeyDestroyFuncVar), NewCallback(ValueDestroyFuncVar))	73	+	var KeyCompareFuncVarRef uintptr
			74	+	if KeyCompareFuncVar != nil {
			75	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
			76	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
			77	+	KeyCompareFuncVarRef = cbRefPtr
			78	+	} else {
			79	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			80	+	cbFn := *KeyCompareFuncVar
			81	+	return cbFn(arg0, arg1, arg2)
			82	+	}
			83	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
			84	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
			85	+	}
			86	+	}
			87	+
			88	+	var KeyDestroyFuncVarRef uintptr
			89	+	if KeyDestroyFuncVar != nil {
			90	+	KeyDestroyFuncVarPtr := uintptr(unsafe.Pointer(KeyDestroyFuncVar))
			91	+	if cbRefPtr, ok := GetCallback(KeyDestroyFuncVarPtr); ok {
			92	+	KeyDestroyFuncVarRef = cbRefPtr
			93	+	} else {
			94	+	fcb := func(arg0 uintptr) {
			95	+	cbFn := *KeyDestroyFuncVar
			96	+	cbFn(arg0)
			97	+	}
			98	+	KeyDestroyFuncVarRef = purego.NewCallback(fcb)
			99	+	SaveCallback(KeyDestroyFuncVarPtr, KeyDestroyFuncVarRef)
			100	+	}
			101	+	}
			102	+
			103	+	var ValueDestroyFuncVarRef uintptr
			104	+	if ValueDestroyFuncVar != nil {
			105	+	ValueDestroyFuncVarPtr := uintptr(unsafe.Pointer(ValueDestroyFuncVar))
			106	+	if cbRefPtr, ok := GetCallback(ValueDestroyFuncVarPtr); ok {
			107	+	ValueDestroyFuncVarRef = cbRefPtr
			108	+	} else {
			109	+	fcb := func(arg0 uintptr) {
			110	+	cbFn := *ValueDestroyFuncVar
			111	+	cbFn(arg0)
			112	+	}
			113	+	ValueDestroyFuncVarRef = purego.NewCallback(fcb)
			114	+	SaveCallback(ValueDestroyFuncVarPtr, ValueDestroyFuncVarRef)
			115	+	}
			116	+	}
			117	+
			118	+	cret := xNewTreeFull(KeyCompareFuncVarRef, KeyCompareDataVar, KeyDestroyFuncVarRef, ValueDestroyFuncVarRef)
59		return cret	119		return cret
60		}	120		}
61			121

@@ -65,7 +125,22 @@ var xNewTreeWithData func(uintptr, uintptr) *Tree
65		// See g_tree_new() for more details.	125		// See g_tree_new() for more details.
66		func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) Tree {	126		func NewTreeWithData(KeyCompareFuncVar CompareDataFunc, KeyCompareDataVar uintptr) Tree {
67			127
68	-	cret := xNewTreeWithData(NewCallback(KeyCompareFuncVar), KeyCompareDataVar)	128	+	var KeyCompareFuncVarRef uintptr
			129	+	if KeyCompareFuncVar != nil {
			130	+	KeyCompareFuncVarPtr := uintptr(unsafe.Pointer(KeyCompareFuncVar))
			131	+	if cbRefPtr, ok := GetCallback(KeyCompareFuncVarPtr); ok {
			132	+	KeyCompareFuncVarRef = cbRefPtr
			133	+	} else {
			134	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			135	+	cbFn := *KeyCompareFuncVar
			136	+	return cbFn(arg0, arg1, arg2)
			137	+	}
			138	+	KeyCompareFuncVarRef = purego.NewCallback(fcb)
			139	+	SaveCallback(KeyCompareFuncVarPtr, KeyCompareFuncVarRef)
			140	+	}
			141	+	}
			142	+
			143	+	cret := xNewTreeWithData(KeyCompareFuncVarRef, KeyCompareDataVar)
69		return cret	144		return cret
70		}	145		}
71			146

@@ -95,7 +170,22 @@ var xTreeForeach func(uintptr, uintptr, uintptr)
95		// the tree, then walk the list and remove each item.	170		// the tree, then walk the list and remove each item.
96		func (x Tree) Foreach(FuncVar TraverseFunc, UserDataVar uintptr) {	171		func (x Tree) Foreach(FuncVar TraverseFunc, UserDataVar uintptr) {
97			172
98	-	xTreeForeach(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	173	+	var FuncVarRef uintptr
			174	+	if FuncVar != nil {
			175	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			176	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			177	+	FuncVarRef = cbRefPtr
			178	+	} else {
			179	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			180	+	cbFn := *FuncVar
			181	+	return cbFn(arg0, arg1, arg2)
			182	+	}
			183	+	FuncVarRef = purego.NewCallback(fcb)
			184	+	SaveCallback(FuncVarPtr, FuncVarRef)
			185	+	}
			186	+	}
			187	+
			188	+	xTreeForeach(x.GoPointer(), FuncVarRef, UserDataVar)
99			189
100		}	190		}
101			191

@@ -111,7 +201,22 @@ var xTreeForeachNode func(uintptr, uintptr, uintptr)
111		// the tree, then walk the list and remove each item.	201		// the tree, then walk the list and remove each item.
112		func (x Tree) ForeachNode(FuncVar TraverseNodeFunc, UserDataVar uintptr) {	202		func (x Tree) ForeachNode(FuncVar TraverseNodeFunc, UserDataVar uintptr) {
113			203
114	-	xTreeForeachNode(x.GoPointer(), NewCallback(FuncVar), UserDataVar)	204	+	var FuncVarRef uintptr
			205	+	if FuncVar != nil {
			206	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			207	+	if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
			208	+	FuncVarRef = cbRefPtr
			209	+	} else {
			210	+	fcb := func(arg0 *TreeNode, arg1 uintptr) bool {
			211	+	cbFn := *FuncVar
			212	+	return cbFn(arg0, arg1)
			213	+	}
			214	+	FuncVarRef = purego.NewCallback(fcb)
			215	+	SaveCallback(FuncVarPtr, FuncVarRef)
			216	+	}
			217	+	}
			218	+
			219	+	xTreeForeachNode(x.GoPointer(), FuncVarRef, UserDataVar)
115			220
116		}	221		}
117			222

@@ -317,7 +422,22 @@ var xTreeSearch func(uintptr, uintptr, uintptr) uintptr
317		// pairs that have a larger key.	422		// pairs that have a larger key.
318		func (x Tree) Search(SearchFuncVar CompareFunc, UserDataVar uintptr) uintptr {	423		func (x Tree) Search(SearchFuncVar CompareFunc, UserDataVar uintptr) uintptr {
319			424
320	-	cret := xTreeSearch(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)	425	+	var SearchFuncVarRef uintptr
			426	+	if SearchFuncVar != nil {
			427	+	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
			428	+	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
			429	+	SearchFuncVarRef = cbRefPtr
			430	+	} else {
			431	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			432	+	cbFn := *SearchFuncVar
			433	+	return cbFn(arg0, arg1)
			434	+	}
			435	+	SearchFuncVarRef = purego.NewCallback(fcb)
			436	+	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
			437	+	}
			438	+	}
			439	+
			440	+	cret := xTreeSearch(x.GoPointer(), SearchFuncVarRef, UserDataVar)
321		return cret	441		return cret
322		}	442		}
323			443

@@ -334,7 +454,22 @@ var xTreeSearchNode func(uintptr, uintptr, uintptr) *TreeNode
334		// pairs that have a larger key.	454		// pairs that have a larger key.
335		func (x Tree) SearchNode(SearchFuncVar CompareFunc, UserDataVar uintptr) *TreeNode {	455		func (x Tree) SearchNode(SearchFuncVar CompareFunc, UserDataVar uintptr) *TreeNode {
336			456
337	-	cret := xTreeSearchNode(x.GoPointer(), NewCallback(SearchFuncVar), UserDataVar)	457	+	var SearchFuncVarRef uintptr
			458	+	if SearchFuncVar != nil {
			459	+	SearchFuncVarPtr := uintptr(unsafe.Pointer(SearchFuncVar))
			460	+	if cbRefPtr, ok := GetCallback(SearchFuncVarPtr); ok {
			461	+	SearchFuncVarRef = cbRefPtr
			462	+	} else {
			463	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			464	+	cbFn := *SearchFuncVar
			465	+	return cbFn(arg0, arg1)
			466	+	}
			467	+	SearchFuncVarRef = purego.NewCallback(fcb)
			468	+	SaveCallback(SearchFuncVarPtr, SearchFuncVarRef)
			469	+	}
			470	+	}
			471	+
			472	+	cret := xTreeSearchNode(x.GoPointer(), SearchFuncVarRef, UserDataVar)
338		return cret	473		return cret
339		}	474		}
340			475

@@ -355,7 +490,22 @@ var xTreeTraverse func(uintptr, uintptr, TraverseType, uintptr)
355		// Calls the given function for each node in the #GTree.	490		// Calls the given function for each node in the #GTree.
356		func (x Tree) Traverse(TraverseFuncVar TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {	491		func (x Tree) Traverse(TraverseFuncVar TraverseFunc, TraverseTypeVar TraverseType, UserDataVar uintptr) {
357			492
358	-	xTreeTraverse(x.GoPointer(), NewCallback(TraverseFuncVar), TraverseTypeVar, UserDataVar)	493	+	var TraverseFuncVarRef uintptr
			494	+	if TraverseFuncVar != nil {
			495	+	TraverseFuncVarPtr := uintptr(unsafe.Pointer(TraverseFuncVar))
			496	+	if cbRefPtr, ok := GetCallback(TraverseFuncVarPtr); ok {
			497	+	TraverseFuncVarRef = cbRefPtr
			498	+	} else {
			499	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) bool {
			500	+	cbFn := *TraverseFuncVar
			501	+	return cbFn(arg0, arg1, arg2)
			502	+	}
			503	+	TraverseFuncVarRef = purego.NewCallback(fcb)
			504	+	SaveCallback(TraverseFuncVarPtr, TraverseFuncVarRef)
			505	+	}
			506	+	}
			507	+
			508	+	xTreeTraverse(x.GoPointer(), TraverseFuncVarRef, TraverseTypeVar, UserDataVar)
359			509
360		}	510		}
361			511

M v4/glib/gunicode.go +3 -3


@@ -1249,7 +1249,7 @@ func Utf8CollateKeyForFilename(StrVar string, LenVar int) string {
1249		return cret	1249		return cret
1250		}	1250		}
1251			1251
1252	-	var xUtf8FindNextChar func(string, string) string	1252	+	var xUtf8FindNextChar func(string, uintptr) string
1253			1253
1254		// Finds the start of the next UTF-8 character in the string after @p.	1254		// Finds the start of the next UTF-8 character in the string after @p.
1255		//	1255		//

@@ -1261,9 +1261,9 @@ var xUtf8FindNextChar func(string, string) string
1261		// string is reached, a pointer to the terminating nul byte is returned. If	1261		// string is reached, a pointer to the terminating nul byte is returned. If
1262		// @end is non-`NULL`, the return value will be `NULL` if the end of the string	1262		// @end is non-`NULL`, the return value will be `NULL` if the end of the string
1263		// is reached.	1263		// is reached.
1264	-	func Utf8FindNextChar(PVar string, EndVar string) string {	1264	+	func Utf8FindNextChar(PVar string, EndVar *string) string {
1265			1265
1266	-	cret := xUtf8FindNextChar(PVar, EndVar)	1266	+	cret := xUtf8FindNextChar(PVar, core.NullableStringToPtr(EndVar))
1267		return cret	1267		return cret
1268		}	1268		}
1269			1269

M v4/glib/guri.go +30 -30


@@ -598,19 +598,19 @@ const (
598		GUriErrorBadFragmentValue UriError = 9	598		GUriErrorBadFragmentValue UriError = 9
599		)	599		)
600			600
601	-	var xUriBuild func(UriFlags, string, string, string, int, string, string, string) *Uri	601	+	var xUriBuild func(UriFlags, string, uintptr, uintptr, int, string, uintptr, uintptr) *Uri
602			602
603		// Creates a new #GUri from the given components according to @flags.	603		// Creates a new #GUri from the given components according to @flags.
604		//	604		//
605		// See also g_uri_build_with_user(), which allows specifying the	605		// See also g_uri_build_with_user(), which allows specifying the
606		// components of the "userinfo" separately.	606		// components of the "userinfo" separately.
607	-	func UriBuild(FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) *Uri {	607	+	func UriBuild(FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) *Uri {
608			608
609	-	cret := xUriBuild(FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar)	609	+	cret := xUriBuild(FlagsVar, SchemeVar, core.NullableStringToPtr(UserinfoVar), core.NullableStringToPtr(HostVar), PortVar, PathVar, core.NullableStringToPtr(QueryVar), core.NullableStringToPtr(FragmentVar))
610		return cret	610		return cret
611		}	611		}
612			612
613	-	var xUriBuildWithUser func(UriFlags, string, string, string, string, string, int, string, string, string) *Uri	613	+	var xUriBuildWithUser func(UriFlags, string, uintptr, uintptr, uintptr, uintptr, int, string, uintptr, uintptr) *Uri
614			614
615		// Creates a new #GUri from the given components according to @flags	615		// Creates a new #GUri from the given components according to @flags
616		// (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The @flags must be	616		// (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The @flags must be

@@ -620,13 +620,13 @@ var xUriBuildWithUser func(UriFlags, string, string, string, string, string, int
620		// In contrast to g_uri_build(), this allows specifying the components	620		// In contrast to g_uri_build(), this allows specifying the components
621		// of the ‘userinfo’ field separately. Note that @user must be non-%NULL	621		// of the ‘userinfo’ field separately. Note that @user must be non-%NULL
622		// if either @password or @auth_params is non-%NULL.	622		// if either @password or @auth_params is non-%NULL.
623	-	func UriBuildWithUser(FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) *Uri {	623	+	func UriBuildWithUser(FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) *Uri {
624			624
625	-	cret := xUriBuildWithUser(FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar)	625	+	cret := xUriBuildWithUser(FlagsVar, SchemeVar, core.NullableStringToPtr(UserVar), core.NullableStringToPtr(PasswordVar), core.NullableStringToPtr(AuthParamsVar), core.NullableStringToPtr(HostVar), PortVar, PathVar, core.NullableStringToPtr(QueryVar), core.NullableStringToPtr(FragmentVar))
626		return cret	626		return cret
627		}	627		}
628			628
629	-	var xUriEscapeBytes func([]byte, uint, string) string	629	+	var xUriEscapeBytes func([]byte, uint, uintptr) string
630			630
631		// Escapes arbitrary data for use in a URI.	631		// Escapes arbitrary data for use in a URI.
632		//	632		//

@@ -639,13 +639,13 @@ var xUriEscapeBytes func([]byte, uint, string) string
639		//	639		//
640		// Though technically incorrect, this will also allow escaping nul	640		// Though technically incorrect, this will also allow escaping nul
641		// bytes as `%“00`.	641		// bytes as `%“00`.
642	-	func UriEscapeBytes(UnescapedVar []byte, LengthVar uint, ReservedCharsAllowedVar string) string {	642	+	func UriEscapeBytes(UnescapedVar []byte, LengthVar uint, ReservedCharsAllowedVar *string) string {
643			643
644	-	cret := xUriEscapeBytes(UnescapedVar, LengthVar, ReservedCharsAllowedVar)	644	+	cret := xUriEscapeBytes(UnescapedVar, LengthVar, core.NullableStringToPtr(ReservedCharsAllowedVar))
645		return cret	645		return cret
646		}	646		}
647			647
648	-	var xUriEscapeString func(string, string, bool) string	648	+	var xUriEscapeString func(string, uintptr, bool) string
649			649
650		// Escapes a string for use in a URI.	650		// Escapes a string for use in a URI.
651		//	651		//

@@ -655,9 +655,9 @@ var xUriEscapeString func(string, string, bool) string
655		// they are not escaped. This is useful for the "reserved" characters	655		// they are not escaped. This is useful for the "reserved" characters
656		// in the URI specification, since those are allowed unescaped in some	656		// in the URI specification, since those are allowed unescaped in some
657		// portions of a URI.	657		// portions of a URI.
658	-	func UriEscapeString(UnescapedVar string, ReservedCharsAllowedVar string, AllowUtf8Var bool) string {	658	+	func UriEscapeString(UnescapedVar string, ReservedCharsAllowedVar *string, AllowUtf8Var bool) string {
659			659
660	-	cret := xUriEscapeString(UnescapedVar, ReservedCharsAllowedVar, AllowUtf8Var)	660	+	cret := xUriEscapeString(UnescapedVar, core.NullableStringToPtr(ReservedCharsAllowedVar), AllowUtf8Var)
661		return cret	661		return cret
662		}	662		}
663			663

@@ -682,7 +682,7 @@ func UriIsValid(UriStringVar string, FlagsVar UriFlags) (bool, error) {
682			682
683		}	683		}
684			684
685	-	var xUriJoin func(UriFlags, string, string, string, int, string, string, string) string	685	+	var xUriJoin func(UriFlags, uintptr, uintptr, uintptr, int, string, uintptr, uintptr) string
686			686
687		// Joins the given components together according to @flags to create	687		// Joins the given components together according to @flags to create
688		// an absolute URI string. @path may not be %NULL (though it may be the empty	688		// an absolute URI string. @path may not be %NULL (though it may be the empty

@@ -698,13 +698,13 @@ var xUriJoin func(UriFlags, string, string, string, int, string, string, string)
698		//	698		//
699		// %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set	699		// %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
700		// in @flags.	700		// in @flags.
701	-	func UriJoin(FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) string {	701	+	func UriJoin(FlagsVar UriFlags, SchemeVar string, UserinfoVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar *string) string {
702			702
703	-	cret := xUriJoin(FlagsVar, SchemeVar, UserinfoVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar)	703	+	cret := xUriJoin(FlagsVar, core.NullableStringToPtr(SchemeVar), core.NullableStringToPtr(UserinfoVar), core.NullableStringToPtr(HostVar), PortVar, PathVar, core.NullableStringToPtr(QueryVar), core.NullableStringToPtr(FragmentVar))
704		return cret	704		return cret
705		}	705		}
706			706
707	-	var xUriJoinWithUser func(UriFlags, string, string, string, string, string, int, string, string, string) string	707	+	var xUriJoinWithUser func(UriFlags, uintptr, uintptr, uintptr, uintptr, uintptr, int, string, uintptr, uintptr) string
708			708
709		// Joins the given components together according to @flags to create	709		// Joins the given components together according to @flags to create
710		// an absolute URI string. @path may not be %NULL (though it may be the empty	710		// an absolute URI string. @path may not be %NULL (though it may be the empty

@@ -715,9 +715,9 @@ var xUriJoinWithUser func(UriFlags, string, string, string, string, string, int,
715		//	715		//
716		// %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set	716		// %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
717		// in @flags.	717		// in @flags.
718	-	func UriJoinWithUser(FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar string) string {	718	+	func UriJoinWithUser(FlagsVar UriFlags, SchemeVar string, UserVar string, PasswordVar string, AuthParamsVar string, HostVar string, PortVar int, PathVar string, QueryVar string, FragmentVar *string) string {
719			719
720	-	cret := xUriJoinWithUser(FlagsVar, SchemeVar, UserVar, PasswordVar, AuthParamsVar, HostVar, PortVar, PathVar, QueryVar, FragmentVar)	720	+	cret := xUriJoinWithUser(FlagsVar, core.NullableStringToPtr(SchemeVar), core.NullableStringToPtr(UserVar), core.NullableStringToPtr(PasswordVar), core.NullableStringToPtr(AuthParamsVar), core.NullableStringToPtr(HostVar), PortVar, PathVar, core.NullableStringToPtr(QueryVar), core.NullableStringToPtr(FragmentVar))
721		return cret	721		return cret
722		}	722		}
723			723

@@ -807,7 +807,7 @@ func UriPeekScheme(UriVar string) string {
807		return cret	807		return cret
808		}	808		}
809			809
810	-	var xUriResolveRelative func(string, string, UriFlags, **Error) string	810	+	var xUriResolveRelative func(uintptr, string, UriFlags, **Error) string
811			811
812		// Parses @uri_ref according to @flags and, if it is a	812		// Parses @uri_ref according to @flags and, if it is a
813		// [relative URI](#relative-and-absolute-uris), resolves it relative to	813		// [relative URI](#relative-and-absolute-uris), resolves it relative to

@@ -816,10 +816,10 @@ var xUriResolveRelative func(string, string, UriFlags, **Error) string
816		//	816		//
817		// (If @base_uri_string is %NULL, this just returns @uri_ref, or	817		// (If @base_uri_string is %NULL, this just returns @uri_ref, or
818		// %NULL if @uri_ref is invalid or not absolute.)	818		// %NULL if @uri_ref is invalid or not absolute.)
819	-	func UriResolveRelative(BaseUriStringVar string, UriRefVar string, FlagsVar UriFlags) (string, error) {	819	+	func UriResolveRelative(BaseUriStringVar *string, UriRefVar string, FlagsVar UriFlags) (string, error) {
820		var cerr *Error	820		var cerr *Error
821			821
822	-	cret := xUriResolveRelative(BaseUriStringVar, UriRefVar, FlagsVar, &cerr)	822	+	cret := xUriResolveRelative(core.NullableStringToPtr(BaseUriStringVar), UriRefVar, FlagsVar, &cerr)
823		if cerr == nil {	823		if cerr == nil {
824		return cret, nil	824		return cret, nil
825		}	825		}

@@ -899,7 +899,7 @@ func UriSplitWithUser(UriRefVar string, FlagsVar UriFlags, SchemeVar *string, Us
899			899
900		}	900		}
901			901
902	-	var xUriUnescapeBytes func(string, int, string, *Error) Bytes	902	+	var xUriUnescapeBytes func(string, int, uintptr, *Error) Bytes
903			903
904		// Unescapes a segment of an escaped string as binary data.	904		// Unescapes a segment of an escaped string as binary data.
905		//	905		//

@@ -911,10 +911,10 @@ var xUriUnescapeBytes func(string, int, string, *Error) Bytes
911		// returned. This is useful if you want to avoid for instance having a slash	911		// returned. This is useful if you want to avoid for instance having a slash
912		// being expanded in an escaped path element, which might confuse pathname	912		// being expanded in an escaped path element, which might confuse pathname
913		// handling.	913		// handling.
914	-	func UriUnescapeBytes(EscapedStringVar string, LengthVar int, IllegalCharactersVar string) (*Bytes, error) {	914	+	func UriUnescapeBytes(EscapedStringVar string, LengthVar int, IllegalCharactersVar string) (Bytes, error) {
915		var cerr *Error	915		var cerr *Error
916			916
917	-	cret := xUriUnescapeBytes(EscapedStringVar, LengthVar, IllegalCharactersVar, &cerr)	917	+	cret := xUriUnescapeBytes(EscapedStringVar, LengthVar, core.NullableStringToPtr(IllegalCharactersVar), &cerr)
918		if cerr == nil {	918		if cerr == nil {
919		return cret, nil	919		return cret, nil
920		}	920		}

@@ -922,7 +922,7 @@ func UriUnescapeBytes(EscapedStringVar string, LengthVar int, IllegalCharactersV
922			922
923		}	923		}
924			924
925	-	var xUriUnescapeSegment func(string, string, string) string	925	+	var xUriUnescapeSegment func(uintptr, uintptr, uintptr) string
926			926
927		// Unescapes a segment of an escaped string.	927		// Unescapes a segment of an escaped string.
928		//	928		//

@@ -934,13 +934,13 @@ var xUriUnescapeSegment func(string, string, string) string
934		//	934		//
935		// Note: `NUL` byte is not accepted in the output, in contrast to	935		// Note: `NUL` byte is not accepted in the output, in contrast to
936		// g_uri_unescape_bytes().	936		// g_uri_unescape_bytes().
937	-	func UriUnescapeSegment(EscapedStringVar string, EscapedStringEndVar string, IllegalCharactersVar string) string {	937	+	func UriUnescapeSegment(EscapedStringVar string, EscapedStringEndVar string, IllegalCharactersVar *string) string {
938			938
939	-	cret := xUriUnescapeSegment(EscapedStringVar, EscapedStringEndVar, IllegalCharactersVar)	939	+	cret := xUriUnescapeSegment(core.NullableStringToPtr(EscapedStringVar), core.NullableStringToPtr(EscapedStringEndVar), core.NullableStringToPtr(IllegalCharactersVar))
940		return cret	940		return cret
941		}	941		}
942			942
943	-	var xUriUnescapeString func(string, string) string	943	+	var xUriUnescapeString func(string, uintptr) string
944			944
945		// Unescapes a whole escaped string.	945		// Unescapes a whole escaped string.
946		//	946		//

@@ -949,9 +949,9 @@ var xUriUnescapeString func(string, string) string
949		// that is an error and %NULL will be returned. This is useful if you	949		// that is an error and %NULL will be returned. This is useful if you
950		// want to avoid for instance having a slash being expanded in an	950		// want to avoid for instance having a slash being expanded in an
951		// escaped path element, which might confuse pathname handling.	951		// escaped path element, which might confuse pathname handling.
952	-	func UriUnescapeString(EscapedStringVar string, IllegalCharactersVar string) string {	952	+	func UriUnescapeString(EscapedStringVar string, IllegalCharactersVar *string) string {
953			953
954	-	cret := xUriUnescapeString(EscapedStringVar, IllegalCharactersVar)	954	+	cret := xUriUnescapeString(EscapedStringVar, core.NullableStringToPtr(IllegalCharactersVar))
955		return cret	955		return cret
956		}	956		}
957			957

M v4/glib/gutils.go +19 -4

 // program.
 func Atexit(FuncVar *VoidFunc) {
-	xAtexit(NewCallback(FuncVar))
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func() {
+				cbFn := *FuncVar
+				cbFn()
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	xAtexit(FuncVarRef)
 }
 }
-var xParseDebugString func(string, []DebugKey, uint) uint
+var xParseDebugString func(uintptr, []DebugKey, uint) uint
 // Parses a string containing debugging options
 // into a %guint containing bit flags. This is used
 //
 // If @string is equal to "help", all the available keys in @keys
 // are printed out to standard error.
-func ParseDebugString(StringVar string, KeysVar []DebugKey, NkeysVar uint) uint {
+func ParseDebugString(StringVar *string, KeysVar []DebugKey, NkeysVar uint) uint {
-	cret := xParseDebugString(StringVar, KeysVar, NkeysVar)
+	cret := xParseDebugString(core.NullableStringToPtr(StringVar), KeysVar, NkeysVar)
 	return cret
 }

M v4/glib/gvariant.go +25 -10

 // process.
 func NewVariantFromData(TypeVar *VariantType, DataVar []byte, SizeVar uint, TrustedVar bool, NotifyVar *DestroyNotify, UserDataVar uintptr) *Variant {
-	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NewCallback(NotifyVar), UserDataVar)
+	var NotifyVarRef uintptr
+	if NotifyVar != nil {
+		NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
+		if cbRefPtr, ok := GetCallback(NotifyVarPtr); ok {
+			NotifyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *NotifyVar
+				cbFn(arg0)
+			}
+			NotifyVarRef = purego.NewCallback(fcb)
+			SaveCallback(NotifyVarPtr, NotifyVarRef)
+		}
+	}
+	cret := xNewVariantFromData(TypeVar, DataVar, SizeVar, TrustedVar, NotifyVarRef, UserDataVar)
 	return cret
 }
 	return cret
 }
-var xNewVariantVa func(string, string, []interface{}) *Variant
+var xNewVariantVa func(string, uintptr, []interface{}) *Variant
 // This function is intended to be used by libraries based on
 // #GVariant that want to provide g_variant_new()-like functionality
 // At this point, the caller will have their own full reference to the
 // result.  This can also be done by adding the result to a container,
 // or by passing it to another g_variant_new() call.
-func NewVariantVa(FormatStringVar string, EndptrVar string, AppVar []interface{}) *Variant {
+func NewVariantVa(FormatStringVar string, EndptrVar *string, AppVar []interface{}) *Variant {
-	cret := xNewVariantVa(FormatStringVar, EndptrVar, AppVar)
+	cret := xNewVariantVa(FormatStringVar, core.NullableStringToPtr(EndptrVar), AppVar)
 	return cret
 }
 	return cret
 }
-var xVariantGetVa func(uintptr, string, string, []interface{})
+var xVariantGetVa func(uintptr, string, uintptr, []interface{})
 // This function is intended to be used by libraries based on #GVariant
 // that want to provide g_variant_get()-like functionality to their
 // the values and also determines if the values are copied or borrowed,
 // see the section on
 // [`GVariant` format strings](gvariant-format-strings.html#pointers).
-func (x *Variant) GetVa(FormatStringVar string, EndptrVar string, AppVar []interface{}) {
+func (x *Variant) GetVa(FormatStringVar string, EndptrVar *string, AppVar []interface{}) {
-	xVariantGetVa(x.GoPointer(), FormatStringVar, EndptrVar, AppVar)
+	xVariantGetVa(x.GoPointer(), FormatStringVar, core.NullableStringToPtr(EndptrVar), AppVar)
 }
 	return cret
 }
-var xVariantParse func(*VariantType, string, string, string, **Error) *Variant
+var xVariantParse func(*VariantType, string, uintptr, uintptr, **Error) *Variant
 // Parses a #GVariant from a text representation.
 //
 // There may be implementation specific restrictions on deeply nested values,
 // which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
 // guaranteed to handle nesting up to at least 64 levels.
-func VariantParse(TypeVar *VariantType, TextVar string, LimitVar string, EndptrVar string) (*Variant, error) {
+func VariantParse(TypeVar *VariantType, TextVar string, LimitVar *string, EndptrVar *string) (*Variant, error) {
 	var cerr *Error
-	cret := xVariantParse(TypeVar, TextVar, LimitVar, EndptrVar, &cerr)
+	cret := xVariantParse(TypeVar, TextVar, core.NullableStringToPtr(LimitVar), core.NullableStringToPtr(EndptrVar), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}

M v4/glib/gvarianttype.go +3 -3


@@ -625,7 +625,7 @@ func VariantTypeStringIsValid(TypeStringVar string) bool {
625		return cret	625		return cret
626		}	626		}
627			627
628	-	var xVariantTypeStringScan func(string, string, *string) bool	628	+	var xVariantTypeStringScan func(string, uintptr, *string) bool
629			629
630		// Scan for a single complete and valid GVariant type string in @string.	630		// Scan for a single complete and valid GVariant type string in @string.
631		//	631		//

@@ -641,9 +641,9 @@ var xVariantTypeStringScan func(string, string, *string) bool
641		//	641		//
642		// For the simple case of checking if a string is a valid type string,	642		// For the simple case of checking if a string is a valid type string,
643		// see [func@GLib.VariantType.string_is_valid].	643		// see [func@GLib.VariantType.string_is_valid].
644	-	func VariantTypeStringScan(StringVar string, LimitVar string, EndptrVar *string) bool {	644	+	func VariantTypeStringScan(StringVar string, LimitVar string, EndptrVar string) bool {
645			645
646	-	cret := xVariantTypeStringScan(StringVar, LimitVar, EndptrVar)	646	+	cret := xVariantTypeStringScan(StringVar, core.NullableStringToPtr(LimitVar), EndptrVar)
647		return cret	647		return cret
648		}	648		}
649			649

M v4/gmodule/gmodule.go +3 -3


@@ -107,7 +107,7 @@ const (
107		GModuleErrorCheckFailedValue ModuleError = 1	107		GModuleErrorCheckFailedValue ModuleError = 1
108		)	108		)
109			109
110	-	var xModuleBuildPath func(string, string) string	110	+	var xModuleBuildPath func(uintptr, string) string
111			111
112		// A portable way to build the filename of a module. The platform-specific	112		// A portable way to build the filename of a module. The platform-specific
113		// prefix and suffix are added to the filename, if needed, and the result	113		// prefix and suffix are added to the filename, if needed, and the result

@@ -122,9 +122,9 @@ var xModuleBuildPath func(string, string) string
122		// @directory of `/lib` and a @module_name of "mylibrary" will return	122		// @directory of `/lib` and a @module_name of "mylibrary" will return
123		// `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the	123		// `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
124		// directory it will return `\Windows\mylibrary.dll`.	124		// directory it will return `\Windows\mylibrary.dll`.
125	-	func ModuleBuildPath(DirectoryVar string, ModuleNameVar string) string {	125	+	func ModuleBuildPath(DirectoryVar *string, ModuleNameVar string) string {
126			126
127	-	cret := xModuleBuildPath(DirectoryVar, ModuleNameVar)	127	+	cret := xModuleBuildPath(core.NullableStringToPtr(DirectoryVar), ModuleNameVar)
128		return cret	128		return cret
129		}	129		}
130			130

M v4/gobject/gbinding.go +2 -2


@@ -306,7 +306,7 @@ func (c *Binding) SetGoPointer(ptr uintptr) {
306		func (x *Binding) SetPropertySourceProperty(value string) {	306		func (x *Binding) SetPropertySourceProperty(value string) {
307		var v Value	307		var v Value
308		v.Init(TypeStringVal)	308		v.Init(TypeStringVal)
309	-	v.SetString(value)	309	+	v.SetString(&value)
310		x.SetProperty("source-property", &v)	310		x.SetProperty("source-property", &v)
311		}	311		}
312			312

@@ -331,7 +331,7 @@ func (x *Binding) GetPropertySourceProperty() string {
331		func (x *Binding) SetPropertyTargetProperty(value string) {	331		func (x *Binding) SetPropertyTargetProperty(value string) {
332		var v Value	332		var v Value
333		v.Init(TypeStringVal)	333		v.Init(TypeStringVal)
334	-	v.SetString(value)	334	+	v.SetString(&value)
335		x.SetProperty("target-property", &v)	335		x.SetProperty("target-property", &v)
336		}	336		}
337			337

M v4/gobject/gbindinggroup.go +48 -1


@@ -2,6 +2,8 @@
2		package gobject	2		package gobject
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -71,7 +73,52 @@ var xBindingGroupBindFull func(uintptr, string, uintptr, string, BindingFlags, u
71		// See g_object_bind_property_full() for more information.	73		// See g_object_bind_property_full() for more information.
72		func (x BindingGroup) BindFull(SourcePropertyVar string, TargetVar Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {	74		func (x BindingGroup) BindFull(SourcePropertyVar string, TargetVar Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify) {
73			75
74	-	xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallbackNullable(TransformToVar), glib.NewCallbackNullable(TransformFromVar), UserDataVar, glib.NewCallback(UserDataDestroyVar))	76	+	var TransformToVarRef uintptr
			77	+	if TransformToVar != nil {
			78	+	TransformToVarPtr := uintptr(unsafe.Pointer(TransformToVar))
			79	+	if cbRefPtr, ok := glib.GetCallback(TransformToVarPtr); ok {
			80	+	TransformToVarRef = cbRefPtr
			81	+	} else {
			82	+	fcb := func(arg0 uintptr, arg1 Value, arg2 Value, arg3 uintptr) bool {
			83	+	cbFn := *TransformToVar
			84	+	return cbFn(arg0, arg1, arg2, arg3)
			85	+	}
			86	+	TransformToVarRef = purego.NewCallback(fcb)
			87	+	glib.SaveCallback(TransformToVarPtr, TransformToVarRef)
			88	+	}
			89	+	}
			90	+
			91	+	var TransformFromVarRef uintptr
			92	+	if TransformFromVar != nil {
			93	+	TransformFromVarPtr := uintptr(unsafe.Pointer(TransformFromVar))
			94	+	if cbRefPtr, ok := glib.GetCallback(TransformFromVarPtr); ok {
			95	+	TransformFromVarRef = cbRefPtr
			96	+	} else {
			97	+	fcb := func(arg0 uintptr, arg1 Value, arg2 Value, arg3 uintptr) bool {
			98	+	cbFn := *TransformFromVar
			99	+	return cbFn(arg0, arg1, arg2, arg3)
			100	+	}
			101	+	TransformFromVarRef = purego.NewCallback(fcb)
			102	+	glib.SaveCallback(TransformFromVarPtr, TransformFromVarRef)
			103	+	}
			104	+	}
			105	+
			106	+	var UserDataDestroyVarRef uintptr
			107	+	if UserDataDestroyVar != nil {
			108	+	UserDataDestroyVarPtr := uintptr(unsafe.Pointer(UserDataDestroyVar))
			109	+	if cbRefPtr, ok := glib.GetCallback(UserDataDestroyVarPtr); ok {
			110	+	UserDataDestroyVarRef = cbRefPtr
			111	+	} else {
			112	+	fcb := func(arg0 uintptr) {
			113	+	cbFn := *UserDataDestroyVar
			114	+	cbFn(arg0)
			115	+	}
			116	+	UserDataDestroyVarRef = purego.NewCallback(fcb)
			117	+	glib.SaveCallback(UserDataDestroyVarPtr, UserDataDestroyVarRef)
			118	+	}
			119	+	}
			120	+
			121	+	xBindingGroupBindFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, UserDataDestroyVarRef)
75			122
76		}	123		}
77			124

M v4/gobject/gboxed.go +33 -1


@@ -2,6 +2,8 @@
2		package gobject	2		package gobject
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/glib"	9		"github.com/jwijenbergh/puregotk/v4/glib"

@@ -47,7 +49,37 @@ var xBoxedTypeRegisterStatic func(string, uintptr, uintptr) types.GType
47		// will create the appropriate `*_get_type()` function for the boxed type.	49		// will create the appropriate `*_get_type()` function for the boxed type.
48		func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar BoxedCopyFunc, BoxedFreeVar BoxedFreeFunc) types.GType {	50		func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar BoxedCopyFunc, BoxedFreeVar BoxedFreeFunc) types.GType {
49			51
50	-	cret := xBoxedTypeRegisterStatic(NameVar, glib.NewCallback(BoxedCopyVar), glib.NewCallback(BoxedFreeVar))	52	+	var BoxedCopyVarRef uintptr
			53	+	if BoxedCopyVar != nil {
			54	+	BoxedCopyVarPtr := uintptr(unsafe.Pointer(BoxedCopyVar))
			55	+	if cbRefPtr, ok := glib.GetCallback(BoxedCopyVarPtr); ok {
			56	+	BoxedCopyVarRef = cbRefPtr
			57	+	} else {
			58	+	fcb := func(arg0 uintptr) uintptr {
			59	+	cbFn := *BoxedCopyVar
			60	+	return cbFn(arg0)
			61	+	}
			62	+	BoxedCopyVarRef = purego.NewCallback(fcb)
			63	+	glib.SaveCallback(BoxedCopyVarPtr, BoxedCopyVarRef)
			64	+	}
			65	+	}
			66	+
			67	+	var BoxedFreeVarRef uintptr
			68	+	if BoxedFreeVar != nil {
			69	+	BoxedFreeVarPtr := uintptr(unsafe.Pointer(BoxedFreeVar))
			70	+	if cbRefPtr, ok := glib.GetCallback(BoxedFreeVarPtr); ok {
			71	+	BoxedFreeVarRef = cbRefPtr
			72	+	} else {
			73	+	fcb := func(arg0 uintptr) {
			74	+	cbFn := *BoxedFreeVar
			75	+	cbFn(arg0)
			76	+	}
			77	+	BoxedFreeVarRef = purego.NewCallback(fcb)
			78	+	glib.SaveCallback(BoxedFreeVarPtr, BoxedFreeVarRef)
			79	+	}
			80	+	}
			81	+
			82	+	cret := xBoxedTypeRegisterStatic(NameVar, BoxedCopyVarRef, BoxedFreeVarRef)
51		return cret	83		return cret
52		}	84		}
53			85

M v4/gobject/gclosure.go +189 -9


@@ -203,7 +203,22 @@ var xClosureAddFinalizeNotifier func(uintptr, uintptr, uintptr)
203		// notifiers will be run before the finalize notifiers.	203		// notifiers will be run before the finalize notifiers.
204		func (x Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {	204		func (x Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
205			205
206	-	xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))	206	+	var NotifyFuncVarRef uintptr
			207	+	if NotifyFuncVar != nil {
			208	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
			209	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
			210	+	NotifyFuncVarRef = cbRefPtr
			211	+	} else {
			212	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			213	+	cbFn := *NotifyFuncVar
			214	+	cbFn(arg0, arg1)
			215	+	}
			216	+	NotifyFuncVarRef = purego.NewCallback(fcb)
			217	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
			218	+	}
			219	+	}
			220	+
			221	+	xClosureAddFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
207			222
208		}	223		}
209			224

@@ -216,7 +231,22 @@ var xClosureAddInvalidateNotifier func(uintptr, uintptr, uintptr)
216		// in an unspecified order.	231		// in an unspecified order.
217		func (x Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {	232		func (x Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
218			233
219	-	xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))	234	+	var NotifyFuncVarRef uintptr
			235	+	if NotifyFuncVar != nil {
			236	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
			237	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
			238	+	NotifyFuncVarRef = cbRefPtr
			239	+	} else {
			240	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			241	+	cbFn := *NotifyFuncVar
			242	+	cbFn(arg0, arg1)
			243	+	}
			244	+	NotifyFuncVarRef = purego.NewCallback(fcb)
			245	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
			246	+	}
			247	+	}
			248	+
			249	+	xClosureAddInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
220			250
221		}	251		}
222			252

@@ -230,7 +260,37 @@ var xClosureAddMarshalGuards func(uintptr, uintptr, uintptr, uintptr, uintptr)
230		// example of marshal guards.	260		// example of marshal guards.
231		func (x Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {	261		func (x Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify) {
232			262
233	-	xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, glib.NewCallback(PreMarshalNotifyVar), PostMarshalDataVar, glib.NewCallback(PostMarshalNotifyVar))	263	+	var PreMarshalNotifyVarRef uintptr
			264	+	if PreMarshalNotifyVar != nil {
			265	+	PreMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PreMarshalNotifyVar))
			266	+	if cbRefPtr, ok := glib.GetCallback(PreMarshalNotifyVarPtr); ok {
			267	+	PreMarshalNotifyVarRef = cbRefPtr
			268	+	} else {
			269	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			270	+	cbFn := *PreMarshalNotifyVar
			271	+	cbFn(arg0, arg1)
			272	+	}
			273	+	PreMarshalNotifyVarRef = purego.NewCallback(fcb)
			274	+	glib.SaveCallback(PreMarshalNotifyVarPtr, PreMarshalNotifyVarRef)
			275	+	}
			276	+	}
			277	+
			278	+	var PostMarshalNotifyVarRef uintptr
			279	+	if PostMarshalNotifyVar != nil {
			280	+	PostMarshalNotifyVarPtr := uintptr(unsafe.Pointer(PostMarshalNotifyVar))
			281	+	if cbRefPtr, ok := glib.GetCallback(PostMarshalNotifyVarPtr); ok {
			282	+	PostMarshalNotifyVarRef = cbRefPtr
			283	+	} else {
			284	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			285	+	cbFn := *PostMarshalNotifyVar
			286	+	cbFn(arg0, arg1)
			287	+	}
			288	+	PostMarshalNotifyVarRef = purego.NewCallback(fcb)
			289	+	glib.SaveCallback(PostMarshalNotifyVarPtr, PostMarshalNotifyVarRef)
			290	+	}
			291	+	}
			292	+
			293	+	xClosureAddMarshalGuards(x.GoPointer(), PreMarshalDataVar, PreMarshalNotifyVarRef, PostMarshalDataVar, PostMarshalNotifyVarRef)
234			294
235		}	295		}
236			296

@@ -283,7 +343,22 @@ var xClosureRemoveFinalizeNotifier func(uintptr, uintptr, uintptr)
283		// Notice that notifiers are automatically removed after they are run.	343		// Notice that notifiers are automatically removed after they are run.
284		func (x Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {	344		func (x Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
285			345
286	-	xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))	346	+	var NotifyFuncVarRef uintptr
			347	+	if NotifyFuncVar != nil {
			348	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
			349	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
			350	+	NotifyFuncVarRef = cbRefPtr
			351	+	} else {
			352	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			353	+	cbFn := *NotifyFuncVar
			354	+	cbFn(arg0, arg1)
			355	+	}
			356	+	NotifyFuncVarRef = purego.NewCallback(fcb)
			357	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
			358	+	}
			359	+	}
			360	+
			361	+	xClosureRemoveFinalizeNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
287			362
288		}	363		}
289			364

@@ -294,7 +369,22 @@ var xClosureRemoveInvalidateNotifier func(uintptr, uintptr, uintptr)
294		// Notice that notifiers are automatically removed after they are run.	369		// Notice that notifiers are automatically removed after they are run.
295		func (x Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {	370		func (x Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar ClosureNotify) {
296			371
297	-	xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, glib.NewCallback(NotifyFuncVar))	372	+	var NotifyFuncVarRef uintptr
			373	+	if NotifyFuncVar != nil {
			374	+	NotifyFuncVarPtr := uintptr(unsafe.Pointer(NotifyFuncVar))
			375	+	if cbRefPtr, ok := glib.GetCallback(NotifyFuncVarPtr); ok {
			376	+	NotifyFuncVarRef = cbRefPtr
			377	+	} else {
			378	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			379	+	cbFn := *NotifyFuncVar
			380	+	cbFn(arg0, arg1)
			381	+	}
			382	+	NotifyFuncVarRef = purego.NewCallback(fcb)
			383	+	glib.SaveCallback(NotifyFuncVarPtr, NotifyFuncVarRef)
			384	+	}
			385	+	}
			386	+
			387	+	xClosureRemoveInvalidateNotifier(x.GoPointer(), NotifyDataVar, NotifyFuncVarRef)
298			388
299		}	389		}
300			390

@@ -312,7 +402,22 @@ var xClosureSetMarshal func(uintptr, uintptr)
312		// See also: g_closure_set_meta_marshal()	402		// See also: g_closure_set_meta_marshal()
313		func (x Closure) SetMarshal(MarshalVar ClosureMarshal) {	403		func (x Closure) SetMarshal(MarshalVar ClosureMarshal) {
314			404
315	-	xClosureSetMarshal(x.GoPointer(), glib.NewCallback(MarshalVar))	405	+	var MarshalVarRef uintptr
			406	+	if MarshalVar != nil {
			407	+	MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
			408	+	if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
			409	+	MarshalVarRef = cbRefPtr
			410	+	} else {
			411	+	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
			412	+	cbFn := *MarshalVar
			413	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
			414	+	}
			415	+	MarshalVarRef = purego.NewCallback(fcb)
			416	+	glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
			417	+	}
			418	+	}
			419	+
			420	+	xClosureSetMarshal(x.GoPointer(), MarshalVarRef)
316			421
317		}	422		}
318			423

@@ -337,7 +442,22 @@ var xClosureSetMetaMarshal func(uintptr, uintptr, uintptr)
337		// @marshal_data argument.	442		// @marshal_data argument.
338		func (x Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar ClosureMarshal) {	443		func (x Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar ClosureMarshal) {
339			444
340	-	xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, glib.NewCallback(MetaMarshalVar))	445	+	var MetaMarshalVarRef uintptr
			446	+	if MetaMarshalVar != nil {
			447	+	MetaMarshalVarPtr := uintptr(unsafe.Pointer(MetaMarshalVar))
			448	+	if cbRefPtr, ok := glib.GetCallback(MetaMarshalVarPtr); ok {
			449	+	MetaMarshalVarRef = cbRefPtr
			450	+	} else {
			451	+	fcb := func(arg0 Closure, arg1 Value, arg2 uint, arg3 []Value, arg4 uintptr, arg5 uintptr) {
			452	+	cbFn := *MetaMarshalVar
			453	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
			454	+	}
			455	+	MetaMarshalVarRef = purego.NewCallback(fcb)
			456	+	glib.SaveCallback(MetaMarshalVarPtr, MetaMarshalVarRef)
			457	+	}
			458	+	}
			459	+
			460	+	xClosureSetMetaMarshal(x.GoPointer(), MarshalDataVar, MetaMarshalVarRef)
341			461
342		}	462		}
343			463

@@ -467,7 +587,37 @@ var xCclosureNew func(uintptr, uintptr, uintptr) *Closure
467		// @destroy_data will be called as a finalize notifier on the #GClosure.	587		// @destroy_data will be called as a finalize notifier on the #GClosure.
468		func CclosureNew(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {	588		func CclosureNew(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
469			589
470	-	cret := xCclosureNew(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))	590	+	var CallbackFuncVarRef uintptr
			591	+	if CallbackFuncVar != nil {
			592	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
			593	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
			594	+	CallbackFuncVarRef = cbRefPtr
			595	+	} else {
			596	+	fcb := func() {
			597	+	cbFn := *CallbackFuncVar
			598	+	cbFn()
			599	+	}
			600	+	CallbackFuncVarRef = purego.NewCallback(fcb)
			601	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
			602	+	}
			603	+	}
			604	+
			605	+	var DestroyDataVarRef uintptr
			606	+	if DestroyDataVar != nil {
			607	+	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
			608	+	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
			609	+	DestroyDataVarRef = cbRefPtr
			610	+	} else {
			611	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			612	+	cbFn := *DestroyDataVar
			613	+	cbFn(arg0, arg1)
			614	+	}
			615	+	DestroyDataVarRef = purego.NewCallback(fcb)
			616	+	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
			617	+	}
			618	+	}
			619	+
			620	+	cret := xCclosureNew(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)
471		return cret	621		return cret
472		}	622		}
473			623

@@ -479,7 +629,37 @@ var xCclosureNewSwap func(uintptr, uintptr, uintptr) *Closure
479		// @destroy_data will be called as a finalize notifier on the #GClosure.	629		// @destroy_data will be called as a finalize notifier on the #GClosure.
480		func CclosureNewSwap(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {	630		func CclosureNewSwap(CallbackFuncVar Callback, UserDataVar uintptr, DestroyDataVar ClosureNotify) *Closure {
481			631
482	-	cret := xCclosureNewSwap(glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallback(DestroyDataVar))	632	+	var CallbackFuncVarRef uintptr
			633	+	if CallbackFuncVar != nil {
			634	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
			635	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
			636	+	CallbackFuncVarRef = cbRefPtr
			637	+	} else {
			638	+	fcb := func() {
			639	+	cbFn := *CallbackFuncVar
			640	+	cbFn()
			641	+	}
			642	+	CallbackFuncVarRef = purego.NewCallback(fcb)
			643	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
			644	+	}
			645	+	}
			646	+
			647	+	var DestroyDataVarRef uintptr
			648	+	if DestroyDataVar != nil {
			649	+	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
			650	+	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
			651	+	DestroyDataVarRef = cbRefPtr
			652	+	} else {
			653	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			654	+	cbFn := *DestroyDataVar
			655	+	cbFn(arg0, arg1)
			656	+	}
			657	+	DestroyDataVarRef = purego.NewCallback(fcb)
			658	+	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
			659	+	}
			660	+	}
			661	+
			662	+	cret := xCclosureNewSwap(CallbackFuncVarRef, UserDataVar, DestroyDataVarRef)
483		return cret	663		return cret
484		}	664		}
485			665

M v4/gobject/gobject.go +277 -14


@@ -2,6 +2,7 @@
2		package gobject	2		package gobject
3			3
4		import (	4		import (
			5	+	"fmt"
5		"structs"	6		"structs"
6		"unsafe"	7		"unsafe"
7			8

@@ -931,7 +932,22 @@ var xCclosureNewObject func(uintptr, uintptr) *Closure
931		// after the object is is freed.	932		// after the object is is freed.
932		func CclosureNewObject(CallbackFuncVar Callback, ObjectVar Object) *Closure {	933		func CclosureNewObject(CallbackFuncVar Callback, ObjectVar Object) *Closure {
933			934
934	-	cret := xCclosureNewObject(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())	935	+	var CallbackFuncVarRef uintptr
			936	+	if CallbackFuncVar != nil {
			937	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
			938	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
			939	+	CallbackFuncVarRef = cbRefPtr
			940	+	} else {
			941	+	fcb := func() {
			942	+	cbFn := *CallbackFuncVar
			943	+	cbFn()
			944	+	}
			945	+	CallbackFuncVarRef = purego.NewCallback(fcb)
			946	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
			947	+	}
			948	+	}
			949	+
			950	+	cret := xCclosureNewObject(CallbackFuncVarRef, ObjectVar.GoPointer())
935		return cret	951		return cret
936		}	952		}
937			953

@@ -944,7 +960,22 @@ var xCclosureNewObjectSwap func(uintptr, uintptr) *Closure
944		// after the object is is freed.	960		// after the object is is freed.
945		func CclosureNewObjectSwap(CallbackFuncVar Callback, ObjectVar Object) *Closure {	961		func CclosureNewObjectSwap(CallbackFuncVar Callback, ObjectVar Object) *Closure {
946			962
947	-	cret := xCclosureNewObjectSwap(glib.NewCallback(CallbackFuncVar), ObjectVar.GoPointer())	963	+	var CallbackFuncVarRef uintptr
			964	+	if CallbackFuncVar != nil {
			965	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
			966	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
			967	+	CallbackFuncVarRef = cbRefPtr
			968	+	} else {
			969	+	fcb := func() {
			970	+	cbFn := *CallbackFuncVar
			971	+	cbFn()
			972	+	}
			973	+	CallbackFuncVarRef = purego.NewCallback(fcb)
			974	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
			975	+	}
			976	+	}
			977	+
			978	+	cret := xCclosureNewObjectSwap(CallbackFuncVarRef, ObjectVar.GoPointer())
948		return cret	979		return cret
949		}	980		}
950			981

@@ -986,7 +1017,22 @@ var xSignalConnectObject func(*TypeInstance, string, uintptr, uintptr, ConnectFl
986		// details.	1017		// details.
987		func SignalConnectObject(InstanceVar TypeInstance, DetailedSignalVar string, CHandlerVar Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {	1018		func SignalConnectObject(InstanceVar TypeInstance, DetailedSignalVar string, CHandlerVar Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32 {
988			1019
989	-	cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, glib.NewCallback(CHandlerVar), GobjectVar.GoPointer(), ConnectFlagsVar)	1020	+	var CHandlerVarRef uintptr
			1021	+	if CHandlerVar != nil {
			1022	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			1023	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			1024	+	CHandlerVarRef = cbRefPtr
			1025	+	} else {
			1026	+	fcb := func() {
			1027	+	cbFn := *CHandlerVar
			1028	+	cbFn()
			1029	+	}
			1030	+	CHandlerVarRef = purego.NewCallback(fcb)
			1031	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			1032	+	}
			1033	+	}
			1034	+
			1035	+	cret := xSignalConnectObject(InstanceVar, DetailedSignalVar, CHandlerVarRef, GobjectVar.GoPointer(), ConnectFlagsVar)
990		return cret	1036		return cret
991		}	1037		}
992			1038

@@ -1198,7 +1244,22 @@ var xObjectAddToggleRef func(uintptr, uintptr, uintptr)
1198		// A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().	1244		// A g_object_add_toggle_ref() must be released with g_object_remove_toggle_ref().
1199		func (x Object) AddToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {	1245		func (x Object) AddToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
1200			1246
1201	-	xObjectAddToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)	1247	+	var NotifyVarRef uintptr
			1248	+	if NotifyVar != nil {
			1249	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1250	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			1251	+	NotifyVarRef = cbRefPtr
			1252	+	} else {
			1253	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
			1254	+	cbFn := *NotifyVar
			1255	+	cbFn(arg0, arg1, arg2)
			1256	+	}
			1257	+	NotifyVarRef = purego.NewCallback(fcb)
			1258	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			1259	+	}
			1260	+	}
			1261	+
			1262	+	xObjectAddToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
1202			1263
1203		}	1264		}
1204			1265

@@ -1298,7 +1359,52 @@ var xObjectBindPropertyFull func(uintptr, string, uintptr, string, BindingFlags,
1298		func (x Object) BindPropertyFull(SourcePropertyVar string, TargetVar Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify) Binding {	1359		func (x Object) BindPropertyFull(SourcePropertyVar string, TargetVar Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar BindingTransformFunc, TransformFromVar BindingTransformFunc, UserDataVar uintptr, NotifyVar glib.DestroyNotify) Binding {
1299		var cls *Binding	1360		var cls *Binding
1300			1361
1301	-	cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, glib.NewCallbackNullable(TransformToVar), glib.NewCallbackNullable(TransformFromVar), UserDataVar, glib.NewCallbackNullable(NotifyVar))	1362	+	var TransformToVarRef uintptr
			1363	+	if TransformToVar != nil {
			1364	+	TransformToVarPtr := uintptr(unsafe.Pointer(TransformToVar))
			1365	+	if cbRefPtr, ok := glib.GetCallback(TransformToVarPtr); ok {
			1366	+	TransformToVarRef = cbRefPtr
			1367	+	} else {
			1368	+	fcb := func(arg0 uintptr, arg1 Value, arg2 Value, arg3 uintptr) bool {
			1369	+	cbFn := *TransformToVar
			1370	+	return cbFn(arg0, arg1, arg2, arg3)
			1371	+	}
			1372	+	TransformToVarRef = purego.NewCallback(fcb)
			1373	+	glib.SaveCallback(TransformToVarPtr, TransformToVarRef)
			1374	+	}
			1375	+	}
			1376	+
			1377	+	var TransformFromVarRef uintptr
			1378	+	if TransformFromVar != nil {
			1379	+	TransformFromVarPtr := uintptr(unsafe.Pointer(TransformFromVar))
			1380	+	if cbRefPtr, ok := glib.GetCallback(TransformFromVarPtr); ok {
			1381	+	TransformFromVarRef = cbRefPtr
			1382	+	} else {
			1383	+	fcb := func(arg0 uintptr, arg1 Value, arg2 Value, arg3 uintptr) bool {
			1384	+	cbFn := *TransformFromVar
			1385	+	return cbFn(arg0, arg1, arg2, arg3)
			1386	+	}
			1387	+	TransformFromVarRef = purego.NewCallback(fcb)
			1388	+	glib.SaveCallback(TransformFromVarPtr, TransformFromVarRef)
			1389	+	}
			1390	+	}
			1391	+
			1392	+	var NotifyVarRef uintptr
			1393	+	if NotifyVar != nil {
			1394	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1395	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			1396	+	NotifyVarRef = cbRefPtr
			1397	+	} else {
			1398	+	fcb := func(arg0 uintptr) {
			1399	+	cbFn := *NotifyVar
			1400	+	cbFn(arg0)
			1401	+	}
			1402	+	NotifyVarRef = purego.NewCallback(fcb)
			1403	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			1404	+	}
			1405	+	}
			1406	+
			1407	+	cret := xObjectBindPropertyFull(x.GoPointer(), SourcePropertyVar, TargetVar.GoPointer(), TargetPropertyVar, FlagsVar, TransformToVarRef, TransformFromVarRef, UserDataVar, NotifyVarRef)
1302			1408
1303		if cret == 0 {	1409		if cret == 0 {
1304		return nil	1410		return nil

@@ -1407,7 +1513,22 @@ var xObjectDupData func(uintptr, string, uintptr, uintptr) uintptr
1407		// object.	1513		// object.
1408		func (x Object) DupData(KeyVar string, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {	1514		func (x Object) DupData(KeyVar string, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {
1409			1515
1410	-	cret := xObjectDupData(x.GoPointer(), KeyVar, glib.NewCallbackNullable(DupFuncVar), UserDataVar)	1516	+	var DupFuncVarRef uintptr
			1517	+	if DupFuncVar != nil {
			1518	+	DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
			1519	+	if cbRefPtr, ok := glib.GetCallback(DupFuncVarPtr); ok {
			1520	+	DupFuncVarRef = cbRefPtr
			1521	+	} else {
			1522	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			1523	+	cbFn := *DupFuncVar
			1524	+	return cbFn(arg0, arg1)
			1525	+	}
			1526	+	DupFuncVarRef = purego.NewCallback(fcb)
			1527	+	glib.SaveCallback(DupFuncVarPtr, DupFuncVarRef)
			1528	+	}
			1529	+	}
			1530	+
			1531	+	cret := xObjectDupData(x.GoPointer(), KeyVar, DupFuncVarRef, UserDataVar)
1411		return cret	1532		return cret
1412		}	1533		}
1413			1534

@@ -1429,7 +1550,22 @@ var xObjectDupQdata func(uintptr, glib.Quark, uintptr, uintptr) uintptr
1429		// object.	1550		// object.
1430		func (x Object) DupQdata(QuarkVar glib.Quark, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {	1551		func (x Object) DupQdata(QuarkVar glib.Quark, DupFuncVar glib.DuplicateFunc, UserDataVar uintptr) uintptr {
1431			1552
1432	-	cret := xObjectDupQdata(x.GoPointer(), QuarkVar, glib.NewCallbackNullable(DupFuncVar), UserDataVar)	1553	+	var DupFuncVarRef uintptr
			1554	+	if DupFuncVar != nil {
			1555	+	DupFuncVarPtr := uintptr(unsafe.Pointer(DupFuncVar))
			1556	+	if cbRefPtr, ok := glib.GetCallback(DupFuncVarPtr); ok {
			1557	+	DupFuncVarRef = cbRefPtr
			1558	+	} else {
			1559	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			1560	+	cbFn := *DupFuncVar
			1561	+	return cbFn(arg0, arg1)
			1562	+	}
			1563	+	DupFuncVarRef = purego.NewCallback(fcb)
			1564	+	glib.SaveCallback(DupFuncVarPtr, DupFuncVarRef)
			1565	+	}
			1566	+	}
			1567	+
			1568	+	cret := xObjectDupQdata(x.GoPointer(), QuarkVar, DupFuncVarRef, UserDataVar)
1433		return cret	1569		return cret
1434		}	1570		}
1435			1571

@@ -1703,7 +1839,22 @@ var xObjectRemoveToggleRef func(uintptr, uintptr, uintptr)
1703		// you must take care of that yourself.	1839		// you must take care of that yourself.
1704		func (x Object) RemoveToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {	1840		func (x Object) RemoveToggleRef(NotifyVar ToggleNotify, DataVar uintptr) {
1705			1841
1706	-	xObjectRemoveToggleRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)	1842	+	var NotifyVarRef uintptr
			1843	+	if NotifyVar != nil {
			1844	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			1845	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			1846	+	NotifyVarRef = cbRefPtr
			1847	+	} else {
			1848	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 bool) {
			1849	+	cbFn := *NotifyVar
			1850	+	cbFn(arg0, arg1, arg2)
			1851	+	}
			1852	+	NotifyVarRef = purego.NewCallback(fcb)
			1853	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			1854	+	}
			1855	+	}
			1856	+
			1857	+	xObjectRemoveToggleRef(x.GoPointer(), NotifyVarRef, DataVar)
1707			1858
1708		}	1859		}
1709			1860

@@ -1738,7 +1889,22 @@ var xObjectReplaceData func(uintptr, string, uintptr, uintptr, uintptr, *glib.De
1738		// for @key.	1889		// for @key.
1739		func (x Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {	1890		func (x Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1740			1891
1741	-	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)	1892	+	var DestroyVarRef uintptr
			1893	+	if DestroyVar != nil {
			1894	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			1895	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			1896	+	DestroyVarRef = cbRefPtr
			1897	+	} else {
			1898	+	fcb := func(arg0 uintptr) {
			1899	+	cbFn := *DestroyVar
			1900	+	cbFn(arg0)
			1901	+	}
			1902	+	DestroyVarRef = purego.NewCallback(fcb)
			1903	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			1904	+	}
			1905	+	}
			1906	+
			1907	+	cret := xObjectReplaceData(x.GoPointer(), KeyVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
1742		return cret	1908		return cret
1743		}	1909		}
1744			1910

@@ -1759,7 +1925,22 @@ var xObjectReplaceQdata func(uintptr, glib.Quark, uintptr, uintptr, uintptr, *gl
1759		// should not destroy the object in the normal way.	1925		// should not destroy the object in the normal way.
1760		func (x Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {	1926		func (x Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) bool {
1761			1927
1762	-	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, glib.NewCallbackNullable(DestroyVar), OldDestroyVar)	1928	+	var DestroyVarRef uintptr
			1929	+	if DestroyVar != nil {
			1930	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			1931	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			1932	+	DestroyVarRef = cbRefPtr
			1933	+	} else {
			1934	+	fcb := func(arg0 uintptr) {
			1935	+	cbFn := *DestroyVar
			1936	+	cbFn(arg0)
			1937	+	}
			1938	+	DestroyVarRef = purego.NewCallback(fcb)
			1939	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			1940	+	}
			1941	+	}
			1942	+
			1943	+	cret := xObjectReplaceQdata(x.GoPointer(), QuarkVar, OldvalVar, NewvalVar, DestroyVarRef, OldDestroyVar)
1763		return cret	1944		return cret
1764		}	1945		}
1765			1946

@@ -1820,7 +2001,22 @@ var xObjectSetDataFull func(uintptr, string, uintptr, uintptr)
1820		// Note that the @destroy callback is not called if @data is %NULL.	2001		// Note that the @destroy callback is not called if @data is %NULL.
1821		func (x Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar glib.DestroyNotify) {	2002		func (x Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar glib.DestroyNotify) {
1822			2003
1823	-	xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, glib.NewCallbackNullable(DestroyVar))	2004	+	var DestroyVarRef uintptr
			2005	+	if DestroyVar != nil {
			2006	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			2007	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			2008	+	DestroyVarRef = cbRefPtr
			2009	+	} else {
			2010	+	fcb := func(arg0 uintptr) {
			2011	+	cbFn := *DestroyVar
			2012	+	cbFn(arg0)
			2013	+	}
			2014	+	DestroyVarRef = purego.NewCallback(fcb)
			2015	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			2016	+	}
			2017	+	}
			2018	+
			2019	+	xObjectSetDataFull(x.GoPointer(), KeyVar, DataVar, DestroyVarRef)
1824			2020
1825		}	2021		}
1826			2022

@@ -1858,7 +2054,22 @@ var xObjectSetQdataFull func(uintptr, glib.Quark, uintptr, uintptr)
1858		// with the same @quark.	2054		// with the same @quark.
1859		func (x Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar glib.DestroyNotify) {	2055		func (x Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar glib.DestroyNotify) {
1860			2056
1861	-	xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallbackNullable(DestroyVar))	2057	+	var DestroyVarRef uintptr
			2058	+	if DestroyVar != nil {
			2059	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			2060	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			2061	+	DestroyVarRef = cbRefPtr
			2062	+	} else {
			2063	+	fcb := func(arg0 uintptr) {
			2064	+	cbFn := *DestroyVar
			2065	+	cbFn(arg0)
			2066	+	}
			2067	+	DestroyVarRef = purego.NewCallback(fcb)
			2068	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			2069	+	}
			2070	+	}
			2071	+
			2072	+	xObjectSetQdataFull(x.GoPointer(), QuarkVar, DataVar, DestroyVarRef)
1862			2073
1863		}	2074		}
1864			2075

@@ -2054,7 +2265,22 @@ var xObjectWeakRef func(uintptr, uintptr, uintptr)
2054		// Use #GWeakRef if thread-safety is required.	2265		// Use #GWeakRef if thread-safety is required.
2055		func (x Object) WeakRef(NotifyVar WeakNotify, DataVar uintptr) {	2266		func (x Object) WeakRef(NotifyVar WeakNotify, DataVar uintptr) {
2056			2267
2057	-	xObjectWeakRef(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)	2268	+	var NotifyVarRef uintptr
			2269	+	if NotifyVar != nil {
			2270	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			2271	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			2272	+	NotifyVarRef = cbRefPtr
			2273	+	} else {
			2274	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			2275	+	cbFn := *NotifyVar
			2276	+	cbFn(arg0, arg1)
			2277	+	}
			2278	+	NotifyVarRef = purego.NewCallback(fcb)
			2279	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			2280	+	}
			2281	+	}
			2282	+
			2283	+	xObjectWeakRef(x.GoPointer(), NotifyVarRef, DataVar)
2058			2284
2059		}	2285		}
2060			2286

@@ -2063,7 +2289,22 @@ var xObjectWeakUnref func(uintptr, uintptr, uintptr)
2063		// Removes a weak reference callback to an object.	2289		// Removes a weak reference callback to an object.
2064		func (x Object) WeakUnref(NotifyVar WeakNotify, DataVar uintptr) {	2290		func (x Object) WeakUnref(NotifyVar WeakNotify, DataVar uintptr) {
2065			2291
2066	-	xObjectWeakUnref(x.GoPointer(), glib.NewCallback(NotifyVar), DataVar)	2292	+	var NotifyVarRef uintptr
			2293	+	if NotifyVar != nil {
			2294	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			2295	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			2296	+	NotifyVarRef = cbRefPtr
			2297	+	} else {
			2298	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			2299	+	cbFn := *NotifyVar
			2300	+	cbFn(arg0, arg1)
			2301	+	}
			2302	+	NotifyVarRef = purego.NewCallback(fcb)
			2303	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			2304	+	}
			2305	+	}
			2306	+
			2307	+	xObjectWeakUnref(x.GoPointer(), NotifyVarRef, DataVar)
2067			2308
2068		}	2309		}
2069			2310

@@ -2124,6 +2365,28 @@ func (x Object) ConnectNotify(cb func(Object, uintptr)) uint32 {
2124		return SignalConnect(x.GoPointer(), "notify", cbRefPtr)	2365		return SignalConnect(x.GoPointer(), "notify", cbRefPtr)
2125		}	2366		}
2126			2367
			2368	+	// ConnectNotifyWithDetail connects to the "notify" signal with a detail string.
			2369	+	// The detail is appended as "notify::<detail>".
			2370	+	func (x Object) ConnectNotifyWithDetail(detail string, cb func(Object, uintptr)) uint32 {
			2371	+	cbPtr := uintptr(unsafe.Pointer(cb))
			2372	+	signalName := fmt.Sprintf("notify::%s", detail)
			2373	+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
			2374	+	return SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			2375	+	}
			2376	+
			2377	+	fcb := func(clsPtr uintptr, PspecVarp uintptr) {
			2378	+	fa := Object{}
			2379	+	fa.Ptr = clsPtr
			2380	+	cbFn := *cb
			2381	+
			2382	+	cbFn(fa, PspecVarp)
			2383	+
			2384	+	}
			2385	+	cbRefPtr := purego.NewCallback(fcb)
			2386	+	glib.SaveCallback(cbPtr, cbRefPtr)
			2387	+	return SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			2388	+	}
			2389	+
2127		var xObjectCompatControl func(uint, uintptr) uint	2390		var xObjectCompatControl func(uint, uintptr) uint
2128			2391
2129		func ObjectCompatControl(WhatVar uint, DataVar uintptr) uint {	2392		func ObjectCompatControl(WhatVar uint, DataVar uintptr) uint {

M v4/gobject/gparam.go +19 -4

 // g_param_spec_set_qdata() with the same @quark.
 func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, glib.NewCallbackNullable(DestroyVar))
+	var DestroyVarRef uintptr
+	if DestroyVar != nil {
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+			DestroyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
+		}
+	}
+	xParamSpecSetQdataFull(x.GoPointer(), QuarkVar, DataVar, DestroyVarRef)
 }
 	c.Ptr = ptr
 }
-var xParamSpecInternal func(types.GType, string, string, string, ParamFlags) uintptr
+var xParamSpecInternal func(types.GType, string, uintptr, uintptr, ParamFlags) uintptr
 // Creates a new #GParamSpec instance.
 //
 // omitted, while for other libraries such as GStreamer and its plugins they
 // are essential. When in doubt, follow the conventions used in the
 // surrounding code and supporting libraries.
-func ParamSpecInternal(ParamTypeVar types.GType, NameVar string, NickVar string, BlurbVar string, FlagsVar ParamFlags) *ParamSpec {
+func ParamSpecInternal(ParamTypeVar types.GType, NameVar string, NickVar *string, BlurbVar *string, FlagsVar ParamFlags) *ParamSpec {
 	var cls *ParamSpec
-	cret := xParamSpecInternal(ParamTypeVar, NameVar, NickVar, BlurbVar, FlagsVar)
+	cret := xParamSpecInternal(ParamTypeVar, NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), FlagsVar)
 	if cret == 0 {
 		return nil

M v4/gobject/gparamspecs.go +66 -66


@@ -8,7 +8,7 @@ import (
8		"github.com/jwijenbergh/puregotk/v4/gobject/types"	8		"github.com/jwijenbergh/puregotk/v4/gobject/types"
9		)	9		)
10			10
11	-	var xNewParamSpecBoolean func(string, string, string, bool, ParamFlags) uintptr	11	+	var xNewParamSpecBoolean func(string, uintptr, uintptr, bool, ParamFlags) uintptr
12			12
13		// Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN	13		// Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
14		// property. In many cases, it may be more appropriate to use an enum with	14		// property. In many cases, it may be more appropriate to use an enum with

@@ -17,10 +17,10 @@ var xNewParamSpecBoolean func(string, string, string, bool, ParamFlags) uintptr
17		// API.	17		// API.
18		//	18		//
19		// See g_param_spec_internal() for details on property names.	19		// See g_param_spec_internal() for details on property names.
20	-	func NewParamSpecBoolean(NameVar string, NickVar string, BlurbVar string, DefaultValueVar bool, FlagsVar ParamFlags) *ParamSpec {	20	+	func NewParamSpecBoolean(NameVar string, NickVar string, BlurbVar string, DefaultValueVar bool, FlagsVar ParamFlags) *ParamSpec {
21		var cls *ParamSpec	21		var cls *ParamSpec
22			22
23	-	cret := xNewParamSpecBoolean(NameVar, NickVar, BlurbVar, DefaultValueVar, FlagsVar)	23	+	cret := xNewParamSpecBoolean(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), DefaultValueVar, FlagsVar)
24			24
25		if cret == 0 {	25		if cret == 0 {
26		return nil	26		return nil

@@ -30,16 +30,16 @@ func NewParamSpecBoolean(NameVar string, NickVar string, BlurbVar string, Defaul
30		return cls	30		return cls
31		}	31		}
32			32
33	-	var xNewParamSpecBoxed func(string, string, string, types.GType, ParamFlags) uintptr	33	+	var xNewParamSpecBoxed func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
34			34
35		// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED	35		// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
36		// derived property.	36		// derived property.
37		//	37		//
38		// See g_param_spec_internal() for details on property names.	38		// See g_param_spec_internal() for details on property names.
39	-	func NewParamSpecBoxed(NameVar string, NickVar string, BlurbVar string, BoxedTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {	39	+	func NewParamSpecBoxed(NameVar string, NickVar string, BlurbVar string, BoxedTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
40		var cls *ParamSpec	40		var cls *ParamSpec
41			41
42	-	cret := xNewParamSpecBoxed(NameVar, NickVar, BlurbVar, BoxedTypeVar, FlagsVar)	42	+	cret := xNewParamSpecBoxed(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), BoxedTypeVar, FlagsVar)
43			43
44		if cret == 0 {	44		if cret == 0 {
45		return nil	45		return nil

@@ -49,13 +49,13 @@ func NewParamSpecBoxed(NameVar string, NickVar string, BlurbVar string, BoxedTyp
49		return cls	49		return cls
50		}	50		}
51			51
52	-	var xNewParamSpecChar func(string, string, string, int8, int8, int8, ParamFlags) uintptr	52	+	var xNewParamSpecChar func(string, uintptr, uintptr, int8, int8, int8, ParamFlags) uintptr
53			53
54		// Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.	54		// Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
55	-	func NewParamSpecChar(NameVar string, NickVar string, BlurbVar string, MinimumVar int8, MaximumVar int8, DefaultValueVar int8, FlagsVar ParamFlags) *ParamSpec {	55	+	func NewParamSpecChar(NameVar string, NickVar string, BlurbVar string, MinimumVar int8, MaximumVar int8, DefaultValueVar int8, FlagsVar ParamFlags) *ParamSpec {
56		var cls *ParamSpec	56		var cls *ParamSpec
57			57
58	-	cret := xNewParamSpecChar(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	58	+	cret := xNewParamSpecChar(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
59			59
60		if cret == 0 {	60		if cret == 0 {
61		return nil	61		return nil

@@ -65,16 +65,16 @@ func NewParamSpecChar(NameVar string, NickVar string, BlurbVar string, MinimumVa
65		return cls	65		return cls
66		}	66		}
67			67
68	-	var xNewParamSpecDouble func(string, string, string, float64, float64, float64, ParamFlags) uintptr	68	+	var xNewParamSpecDouble func(string, uintptr, uintptr, float64, float64, float64, ParamFlags) uintptr
69			69
70		// Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE	70		// Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
71		// property.	71		// property.
72		//	72		//
73		// See g_param_spec_internal() for details on property names.	73		// See g_param_spec_internal() for details on property names.
74	-	func NewParamSpecDouble(NameVar string, NickVar string, BlurbVar string, MinimumVar float64, MaximumVar float64, DefaultValueVar float64, FlagsVar ParamFlags) *ParamSpec {	74	+	func NewParamSpecDouble(NameVar string, NickVar string, BlurbVar string, MinimumVar float64, MaximumVar float64, DefaultValueVar float64, FlagsVar ParamFlags) *ParamSpec {
75		var cls *ParamSpec	75		var cls *ParamSpec
76			76
77	-	cret := xNewParamSpecDouble(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	77	+	cret := xNewParamSpecDouble(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
78			78
79		if cret == 0 {	79		if cret == 0 {
80		return nil	80		return nil

@@ -84,16 +84,16 @@ func NewParamSpecDouble(NameVar string, NickVar string, BlurbVar string, Minimum
84		return cls	84		return cls
85		}	85		}
86			86
87	-	var xNewParamSpecEnum func(string, string, string, types.GType, int, ParamFlags) uintptr	87	+	var xNewParamSpecEnum func(string, uintptr, uintptr, types.GType, int, ParamFlags) uintptr
88			88
89		// Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM	89		// Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
90		// property.	90		// property.
91		//	91		//
92		// See g_param_spec_internal() for details on property names.	92		// See g_param_spec_internal() for details on property names.
93	-	func NewParamSpecEnum(NameVar string, NickVar string, BlurbVar string, EnumTypeVar types.GType, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {	93	+	func NewParamSpecEnum(NameVar string, NickVar string, BlurbVar string, EnumTypeVar types.GType, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
94		var cls *ParamSpec	94		var cls *ParamSpec
95			95
96	-	cret := xNewParamSpecEnum(NameVar, NickVar, BlurbVar, EnumTypeVar, DefaultValueVar, FlagsVar)	96	+	cret := xNewParamSpecEnum(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), EnumTypeVar, DefaultValueVar, FlagsVar)
97			97
98		if cret == 0 {	98		if cret == 0 {
99		return nil	99		return nil

@@ -103,16 +103,16 @@ func NewParamSpecEnum(NameVar string, NickVar string, BlurbVar string, EnumTypeV
103		return cls	103		return cls
104		}	104		}
105			105
106	-	var xNewParamSpecFlags func(string, string, string, types.GType, uint, ParamFlags) uintptr	106	+	var xNewParamSpecFlags func(string, uintptr, uintptr, types.GType, uint, ParamFlags) uintptr
107			107
108		// Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS	108		// Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
109		// property.	109		// property.
110		//	110		//
111		// See g_param_spec_internal() for details on property names.	111		// See g_param_spec_internal() for details on property names.
112	-	func NewParamSpecFlags(NameVar string, NickVar string, BlurbVar string, FlagsTypeVar types.GType, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {	112	+	func NewParamSpecFlags(NameVar string, NickVar string, BlurbVar string, FlagsTypeVar types.GType, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
113		var cls *ParamSpec	113		var cls *ParamSpec
114			114
115	-	cret := xNewParamSpecFlags(NameVar, NickVar, BlurbVar, FlagsTypeVar, DefaultValueVar, FlagsVar)	115	+	cret := xNewParamSpecFlags(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), FlagsTypeVar, DefaultValueVar, FlagsVar)
116			116
117		if cret == 0 {	117		if cret == 0 {
118		return nil	118		return nil

@@ -122,15 +122,15 @@ func NewParamSpecFlags(NameVar string, NickVar string, BlurbVar string, FlagsTyp
122		return cls	122		return cls
123		}	123		}
124			124
125	-	var xNewParamSpecFloat func(string, string, string, float32, float32, float32, ParamFlags) uintptr	125	+	var xNewParamSpecFloat func(string, uintptr, uintptr, float32, float32, float32, ParamFlags) uintptr
126			126
127		// Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.	127		// Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
128		//	128		//
129		// See g_param_spec_internal() for details on property names.	129		// See g_param_spec_internal() for details on property names.
130	-	func NewParamSpecFloat(NameVar string, NickVar string, BlurbVar string, MinimumVar float32, MaximumVar float32, DefaultValueVar float32, FlagsVar ParamFlags) *ParamSpec {	130	+	func NewParamSpecFloat(NameVar string, NickVar string, BlurbVar string, MinimumVar float32, MaximumVar float32, DefaultValueVar float32, FlagsVar ParamFlags) *ParamSpec {
131		var cls *ParamSpec	131		var cls *ParamSpec
132			132
133	-	cret := xNewParamSpecFloat(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	133	+	cret := xNewParamSpecFloat(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
134			134
135		if cret == 0 {	135		if cret == 0 {
136		return nil	136		return nil

@@ -140,16 +140,16 @@ func NewParamSpecFloat(NameVar string, NickVar string, BlurbVar string, MinimumV
140		return cls	140		return cls
141		}	141		}
142			142
143	-	var xParamSpecGtype func(string, string, string, types.GType, ParamFlags) uintptr	143	+	var xParamSpecGtype func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
144			144
145		// Creates a new #GParamSpecGType instance specifying a	145		// Creates a new #GParamSpecGType instance specifying a
146		// %G_TYPE_GTYPE property.	146		// %G_TYPE_GTYPE property.
147		//	147		//
148		// See g_param_spec_internal() for details on property names.	148		// See g_param_spec_internal() for details on property names.
149	-	func ParamSpecGtype(NameVar string, NickVar string, BlurbVar string, IsATypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {	149	+	func ParamSpecGtype(NameVar string, NickVar string, BlurbVar string, IsATypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
150		var cls *ParamSpec	150		var cls *ParamSpec
151			151
152	-	cret := xParamSpecGtype(NameVar, NickVar, BlurbVar, IsATypeVar, FlagsVar)	152	+	cret := xParamSpecGtype(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), IsATypeVar, FlagsVar)
153			153
154		if cret == 0 {	154		if cret == 0 {
155		return nil	155		return nil

@@ -159,15 +159,15 @@ func ParamSpecGtype(NameVar string, NickVar string, BlurbVar string, IsATypeVar
159		return cls	159		return cls
160		}	160		}
161			161
162	-	var xNewParamSpecInt func(string, string, string, int, int, int, ParamFlags) uintptr	162	+	var xNewParamSpecInt func(string, uintptr, uintptr, int, int, int, ParamFlags) uintptr
163			163
164		// Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.	164		// Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
165		//	165		//
166		// See g_param_spec_internal() for details on property names.	166		// See g_param_spec_internal() for details on property names.
167	-	func NewParamSpecInt(NameVar string, NickVar string, BlurbVar string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {	167	+	func NewParamSpecInt(NameVar string, NickVar string, BlurbVar string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec {
168		var cls *ParamSpec	168		var cls *ParamSpec
169			169
170	-	cret := xNewParamSpecInt(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	170	+	cret := xNewParamSpecInt(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
171			171
172		if cret == 0 {	172		if cret == 0 {
173		return nil	173		return nil

@@ -177,15 +177,15 @@ func NewParamSpecInt(NameVar string, NickVar string, BlurbVar string, MinimumVar
177		return cls	177		return cls
178		}	178		}
179			179
180	-	var xNewParamSpecInt64 func(string, string, string, int64, int64, int64, ParamFlags) uintptr	180	+	var xNewParamSpecInt64 func(string, uintptr, uintptr, int64, int64, int64, ParamFlags) uintptr
181			181
182		// Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.	182		// Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
183		//	183		//
184		// See g_param_spec_internal() for details on property names.	184		// See g_param_spec_internal() for details on property names.
185	-	func NewParamSpecInt64(NameVar string, NickVar string, BlurbVar string, MinimumVar int64, MaximumVar int64, DefaultValueVar int64, FlagsVar ParamFlags) *ParamSpec {	185	+	func NewParamSpecInt64(NameVar string, NickVar string, BlurbVar string, MinimumVar int64, MaximumVar int64, DefaultValueVar int64, FlagsVar ParamFlags) *ParamSpec {
186		var cls *ParamSpec	186		var cls *ParamSpec
187			187
188	-	cret := xNewParamSpecInt64(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	188	+	cret := xNewParamSpecInt64(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
189			189
190		if cret == 0 {	190		if cret == 0 {
191		return nil	191		return nil

@@ -195,15 +195,15 @@ func NewParamSpecInt64(NameVar string, NickVar string, BlurbVar string, MinimumV
195		return cls	195		return cls
196		}	196		}
197			197
198	-	var xNewParamSpecLong func(string, string, string, int32, int32, int32, ParamFlags) uintptr	198	+	var xNewParamSpecLong func(string, uintptr, uintptr, int32, int32, int32, ParamFlags) uintptr
199			199
200		// Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.	200		// Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
201		//	201		//
202		// See g_param_spec_internal() for details on property names.	202		// See g_param_spec_internal() for details on property names.
203	-	func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVar int32, MaximumVar int32, DefaultValueVar int32, FlagsVar ParamFlags) *ParamSpec {	203	+	func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVar int32, MaximumVar int32, DefaultValueVar int32, FlagsVar ParamFlags) *ParamSpec {
204		var cls *ParamSpec	204		var cls *ParamSpec
205			205
206	-	cret := xNewParamSpecLong(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	206	+	cret := xNewParamSpecLong(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
207			207
208		if cret == 0 {	208		if cret == 0 {
209		return nil	209		return nil

@@ -213,16 +213,16 @@ func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVa
213		return cls	213		return cls
214		}	214		}
215			215
216	-	var xNewParamSpecObject func(string, string, string, types.GType, ParamFlags) uintptr	216	+	var xNewParamSpecObject func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
217			217
218		// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT	218		// Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
219		// derived property.	219		// derived property.
220		//	220		//
221		// See g_param_spec_internal() for details on property names.	221		// See g_param_spec_internal() for details on property names.
222	-	func NewParamSpecObject(NameVar string, NickVar string, BlurbVar string, ObjectTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {	222	+	func NewParamSpecObject(NameVar string, NickVar string, BlurbVar string, ObjectTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
223		var cls *ParamSpec	223		var cls *ParamSpec
224			224
225	-	cret := xNewParamSpecObject(NameVar, NickVar, BlurbVar, ObjectTypeVar, FlagsVar)	225	+	cret := xNewParamSpecObject(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), ObjectTypeVar, FlagsVar)
226			226
227		if cret == 0 {	227		if cret == 0 {
228		return nil	228		return nil

@@ -250,16 +250,16 @@ func NewParamSpecOverride(NameVar string, OverriddenVar ParamSpec) ParamSpec {
250		return cls	250		return cls
251		}	251		}
252			252
253	-	var xNewParamSpecParam func(string, string, string, types.GType, ParamFlags) uintptr	253	+	var xNewParamSpecParam func(string, uintptr, uintptr, types.GType, ParamFlags) uintptr
254			254
255		// Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM	255		// Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
256		// property.	256		// property.
257		//	257		//
258		// See g_param_spec_internal() for details on property names.	258		// See g_param_spec_internal() for details on property names.
259	-	func NewParamSpecParam(NameVar string, NickVar string, BlurbVar string, ParamTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {	259	+	func NewParamSpecParam(NameVar string, NickVar string, BlurbVar string, ParamTypeVar types.GType, FlagsVar ParamFlags) *ParamSpec {
260		var cls *ParamSpec	260		var cls *ParamSpec
261			261
262	-	cret := xNewParamSpecParam(NameVar, NickVar, BlurbVar, ParamTypeVar, FlagsVar)	262	+	cret := xNewParamSpecParam(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), ParamTypeVar, FlagsVar)
263			263
264		if cret == 0 {	264		if cret == 0 {
265		return nil	265		return nil

@@ -269,17 +269,17 @@ func NewParamSpecParam(NameVar string, NickVar string, BlurbVar string, ParamTyp
269		return cls	269		return cls
270		}	270		}
271			271
272	-	var xNewParamSpecPointer func(string, string, string, ParamFlags) uintptr	272	+	var xNewParamSpecPointer func(string, uintptr, uintptr, ParamFlags) uintptr
273			273
274		// Creates a new #GParamSpecPointer instance specifying a pointer property.	274		// Creates a new #GParamSpecPointer instance specifying a pointer property.
275		// Where possible, it is better to use g_param_spec_object() or	275		// Where possible, it is better to use g_param_spec_object() or
276		// g_param_spec_boxed() to expose memory management information.	276		// g_param_spec_boxed() to expose memory management information.
277		//	277		//
278		// See g_param_spec_internal() for details on property names.	278		// See g_param_spec_internal() for details on property names.
279	-	func NewParamSpecPointer(NameVar string, NickVar string, BlurbVar string, FlagsVar ParamFlags) *ParamSpec {	279	+	func NewParamSpecPointer(NameVar string, NickVar string, BlurbVar string, FlagsVar ParamFlags) *ParamSpec {
280		var cls *ParamSpec	280		var cls *ParamSpec
281			281
282	-	cret := xNewParamSpecPointer(NameVar, NickVar, BlurbVar, FlagsVar)	282	+	cret := xNewParamSpecPointer(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), FlagsVar)
283			283
284		if cret == 0 {	284		if cret == 0 {
285		return nil	285		return nil

@@ -289,15 +289,15 @@ func NewParamSpecPointer(NameVar string, NickVar string, BlurbVar string, FlagsV
289		return cls	289		return cls
290		}	290		}
291			291
292	-	var xNewParamSpecString func(string, string, string, string, ParamFlags) uintptr	292	+	var xNewParamSpecString func(string, uintptr, uintptr, uintptr, ParamFlags) uintptr
293			293
294		// Creates a new #GParamSpecString instance.	294		// Creates a new #GParamSpecString instance.
295		//	295		//
296		// See g_param_spec_internal() for details on property names.	296		// See g_param_spec_internal() for details on property names.
297	-	func NewParamSpecString(NameVar string, NickVar string, BlurbVar string, DefaultValueVar string, FlagsVar ParamFlags) *ParamSpec {	297	+	func NewParamSpecString(NameVar string, NickVar string, BlurbVar string, DefaultValueVar string, FlagsVar ParamFlags) ParamSpec {
298		var cls *ParamSpec	298		var cls *ParamSpec
299			299
300	-	cret := xNewParamSpecString(NameVar, NickVar, BlurbVar, DefaultValueVar, FlagsVar)	300	+	cret := xNewParamSpecString(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), core.NullableStringToPtr(DefaultValueVar), FlagsVar)
301			301
302		if cret == 0 {	302		if cret == 0 {
303		return nil	303		return nil

@@ -307,13 +307,13 @@ func NewParamSpecString(NameVar string, NickVar string, BlurbVar string, Default
307		return cls	307		return cls
308		}	308		}
309			309
310	-	var xParamSpecUchar func(string, string, string, byte, byte, byte, ParamFlags) uintptr	310	+	var xParamSpecUchar func(string, uintptr, uintptr, byte, byte, byte, ParamFlags) uintptr
311			311
312		// Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.	312		// Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
313	-	func ParamSpecUchar(NameVar string, NickVar string, BlurbVar string, MinimumVar byte, MaximumVar byte, DefaultValueVar byte, FlagsVar ParamFlags) *ParamSpec {	313	+	func ParamSpecUchar(NameVar string, NickVar string, BlurbVar string, MinimumVar byte, MaximumVar byte, DefaultValueVar byte, FlagsVar ParamFlags) *ParamSpec {
314		var cls *ParamSpec	314		var cls *ParamSpec
315			315
316	-	cret := xParamSpecUchar(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	316	+	cret := xParamSpecUchar(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
317			317
318		if cret == 0 {	318		if cret == 0 {
319		return nil	319		return nil

@@ -323,15 +323,15 @@ func ParamSpecUchar(NameVar string, NickVar string, BlurbVar string, MinimumVar
323		return cls	323		return cls
324		}	324		}
325			325
326	-	var xParamSpecUint func(string, string, string, uint, uint, uint, ParamFlags) uintptr	326	+	var xParamSpecUint func(string, uintptr, uintptr, uint, uint, uint, ParamFlags) uintptr
327			327
328		// Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.	328		// Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
329		//	329		//
330		// See g_param_spec_internal() for details on property names.	330		// See g_param_spec_internal() for details on property names.
331	-	func ParamSpecUint(NameVar string, NickVar string, BlurbVar string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {	331	+	func ParamSpecUint(NameVar string, NickVar string, BlurbVar string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec {
332		var cls *ParamSpec	332		var cls *ParamSpec
333			333
334	-	cret := xParamSpecUint(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	334	+	cret := xParamSpecUint(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
335			335
336		if cret == 0 {	336		if cret == 0 {
337		return nil	337		return nil

@@ -341,16 +341,16 @@ func ParamSpecUint(NameVar string, NickVar string, BlurbVar string, MinimumVar u
341		return cls	341		return cls
342		}	342		}
343			343
344	-	var xParamSpecUint64 func(string, string, string, uint64, uint64, uint64, ParamFlags) uintptr	344	+	var xParamSpecUint64 func(string, uintptr, uintptr, uint64, uint64, uint64, ParamFlags) uintptr
345			345
346		// Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64	346		// Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
347		// property.	347		// property.
348		//	348		//
349		// See g_param_spec_internal() for details on property names.	349		// See g_param_spec_internal() for details on property names.
350	-	func ParamSpecUint64(NameVar string, NickVar string, BlurbVar string, MinimumVar uint64, MaximumVar uint64, DefaultValueVar uint64, FlagsVar ParamFlags) *ParamSpec {	350	+	func ParamSpecUint64(NameVar string, NickVar string, BlurbVar string, MinimumVar uint64, MaximumVar uint64, DefaultValueVar uint64, FlagsVar ParamFlags) *ParamSpec {
351		var cls *ParamSpec	351		var cls *ParamSpec
352			352
353	-	cret := xParamSpecUint64(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	353	+	cret := xParamSpecUint64(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
354			354
355		if cret == 0 {	355		if cret == 0 {
356		return nil	356		return nil

@@ -360,16 +360,16 @@ func ParamSpecUint64(NameVar string, NickVar string, BlurbVar string, MinimumVar
360		return cls	360		return cls
361		}	361		}
362			362
363	-	var xParamSpecUlong func(string, string, string, uint32, uint32, uint32, ParamFlags) uintptr	363	+	var xParamSpecUlong func(string, uintptr, uintptr, uint32, uint32, uint32, ParamFlags) uintptr
364			364
365		// Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG	365		// Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
366		// property.	366		// property.
367		//	367		//
368		// See g_param_spec_internal() for details on property names.	368		// See g_param_spec_internal() for details on property names.
369	-	func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar uint32, MaximumVar uint32, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {	369	+	func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar uint32, MaximumVar uint32, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {
370		var cls *ParamSpec	370		var cls *ParamSpec
371			371
372	-	cret := xParamSpecUlong(NameVar, NickVar, BlurbVar, MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)	372	+	cret := xParamSpecUlong(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), MinimumVar, MaximumVar, DefaultValueVar, FlagsVar)
373			373
374		if cret == 0 {	374		if cret == 0 {
375		return nil	375		return nil

@@ -379,17 +379,17 @@ func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar
379		return cls	379		return cls
380		}	380		}
381			381
382	-	var xNewParamSpecUnichar func(string, string, string, uint32, ParamFlags) uintptr	382	+	var xNewParamSpecUnichar func(string, uintptr, uintptr, uint32, ParamFlags) uintptr
383			383
384		// Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT	384		// Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
385		// property. #GValue structures for this property can be accessed with	385		// property. #GValue structures for this property can be accessed with
386		// g_value_set_uint() and g_value_get_uint().	386		// g_value_set_uint() and g_value_get_uint().
387		//	387		//
388		// See g_param_spec_internal() for details on property names.	388		// See g_param_spec_internal() for details on property names.
389	-	func NewParamSpecUnichar(NameVar string, NickVar string, BlurbVar string, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {	389	+	func NewParamSpecUnichar(NameVar string, NickVar string, BlurbVar string, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec {
390		var cls *ParamSpec	390		var cls *ParamSpec
391			391
392	-	cret := xNewParamSpecUnichar(NameVar, NickVar, BlurbVar, DefaultValueVar, FlagsVar)	392	+	cret := xNewParamSpecUnichar(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), DefaultValueVar, FlagsVar)
393			393
394		if cret == 0 {	394		if cret == 0 {
395		return nil	395		return nil

@@ -399,7 +399,7 @@ func NewParamSpecUnichar(NameVar string, NickVar string, BlurbVar string, Defaul
399		return cls	399		return cls
400		}	400		}
401			401
402	-	var xNewParamSpecValueArray func(string, string, string, uintptr, ParamFlags) uintptr	402	+	var xNewParamSpecValueArray func(string, uintptr, uintptr, uintptr, ParamFlags) uintptr
403			403
404		// Creates a new #GParamSpecValueArray instance specifying a	404		// Creates a new #GParamSpecValueArray instance specifying a
405		// %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a	405		// %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a

@@ -407,10 +407,10 @@ var xNewParamSpecValueArray func(string, string, string, uintptr, ParamFlags) ui
407		// can be accessed with g_value_set_boxed() and g_value_get_boxed().	407		// can be accessed with g_value_set_boxed() and g_value_get_boxed().
408		//	408		//
409		// See g_param_spec_internal() for details on property names.	409		// See g_param_spec_internal() for details on property names.
410	-	func NewParamSpecValueArray(NameVar string, NickVar string, BlurbVar string, ElementSpecVar ParamSpec, FlagsVar ParamFlags) ParamSpec {	410	+	func NewParamSpecValueArray(NameVar string, NickVar string, BlurbVar string, ElementSpecVar ParamSpec, FlagsVar ParamFlags) ParamSpec {
411		var cls *ParamSpec	411		var cls *ParamSpec
412			412
413	-	cret := xNewParamSpecValueArray(NameVar, NickVar, BlurbVar, ElementSpecVar.GoPointer(), FlagsVar)	413	+	cret := xNewParamSpecValueArray(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), ElementSpecVar.GoPointer(), FlagsVar)
414			414
415		if cret == 0 {	415		if cret == 0 {
416		return nil	416		return nil

@@ -420,7 +420,7 @@ func NewParamSpecValueArray(NameVar string, NickVar string, BlurbVar string, Ele
420		return cls	420		return cls
421		}	421		}
422			422
423	-	var xNewParamSpecVariant func(string, string, string, glib.VariantType, glib.Variant, ParamFlags) uintptr	423	+	var xNewParamSpecVariant func(string, uintptr, uintptr, glib.VariantType, glib.Variant, ParamFlags) uintptr
424			424
425		// Creates a new #GParamSpecVariant instance specifying a #GVariant	425		// Creates a new #GParamSpecVariant instance specifying a #GVariant
426		// property.	426		// property.

@@ -428,10 +428,10 @@ var xNewParamSpecVariant func(string, string, string, glib.VariantType, glib.V
428		// If @default_value is floating, it is consumed.	428		// If @default_value is floating, it is consumed.
429		//	429		//
430		// See g_param_spec_internal() for details on property names.	430		// See g_param_spec_internal() for details on property names.
431	-	func NewParamSpecVariant(NameVar string, NickVar string, BlurbVar string, TypeVar glib.VariantType, DefaultValueVar glib.Variant, FlagsVar ParamFlags) *ParamSpec {	431	+	func NewParamSpecVariant(NameVar string, NickVar string, BlurbVar string, TypeVar glib.VariantType, DefaultValueVar glib.Variant, FlagsVar ParamFlags) *ParamSpec {
432		var cls *ParamSpec	432		var cls *ParamSpec
433			433
434	-	cret := xNewParamSpecVariant(NameVar, NickVar, BlurbVar, TypeVar, DefaultValueVar, FlagsVar)	434	+	cret := xNewParamSpecVariant(NameVar, core.NullableStringToPtr(NickVar), core.NullableStringToPtr(BlurbVar), TypeVar, DefaultValueVar, FlagsVar)
435			435
436		if cret == 0 {	436		if cret == 0 {
437		return nil	437		return nil

M v4/gobject/gsignal.go +157 -7


@@ -228,7 +228,37 @@ var xSignalAddEmissionHook func(uint, glib.Quark, uintptr, uintptr, uintptr) uin
228		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.	228		// for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
229		func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {	229		func SignalAddEmissionHook(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar SignalEmissionHook, HookDataVar uintptr, DataDestroyVar glib.DestroyNotify) uint32 {
230			230
231	-	cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, glib.NewCallback(HookFuncVar), HookDataVar, glib.NewCallbackNullable(DataDestroyVar))	231	+	var HookFuncVarRef uintptr
			232	+	if HookFuncVar != nil {
			233	+	HookFuncVarPtr := uintptr(unsafe.Pointer(HookFuncVar))
			234	+	if cbRefPtr, ok := glib.GetCallback(HookFuncVarPtr); ok {
			235	+	HookFuncVarRef = cbRefPtr
			236	+	} else {
			237	+	fcb := func(arg0 *SignalInvocationHint, arg1 uint, arg2 []Value, arg3 uintptr) bool {
			238	+	cbFn := *HookFuncVar
			239	+	return cbFn(arg0, arg1, arg2, arg3)
			240	+	}
			241	+	HookFuncVarRef = purego.NewCallback(fcb)
			242	+	glib.SaveCallback(HookFuncVarPtr, HookFuncVarRef)
			243	+	}
			244	+	}
			245	+
			246	+	var DataDestroyVarRef uintptr
			247	+	if DataDestroyVar != nil {
			248	+	DataDestroyVarPtr := uintptr(unsafe.Pointer(DataDestroyVar))
			249	+	if cbRefPtr, ok := glib.GetCallback(DataDestroyVarPtr); ok {
			250	+	DataDestroyVarRef = cbRefPtr
			251	+	} else {
			252	+	fcb := func(arg0 uintptr) {
			253	+	cbFn := *DataDestroyVar
			254	+	cbFn(arg0)
			255	+	}
			256	+	DataDestroyVarRef = purego.NewCallback(fcb)
			257	+	glib.SaveCallback(DataDestroyVarPtr, DataDestroyVarRef)
			258	+	}
			259	+	}
			260	+
			261	+	cret := xSignalAddEmissionHook(SignalIdVar, DetailVar, HookFuncVarRef, HookDataVar, DataDestroyVarRef)
232		return cret	262		return cret
233		}	263		}
234			264

@@ -313,7 +343,37 @@ var xSignalConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectF
313		// details.	343		// details.
314		func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {	344		func SignalConnectData(InstanceVar Object, DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32 {
315			345
316	-	cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallbackNullable(DestroyDataVar), ConnectFlagsVar)	346	+	var CHandlerVarRef uintptr
			347	+	if CHandlerVar != nil {
			348	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			349	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			350	+	CHandlerVarRef = cbRefPtr
			351	+	} else {
			352	+	fcb := func() {
			353	+	cbFn := *CHandlerVar
			354	+	cbFn()
			355	+	}
			356	+	CHandlerVarRef = purego.NewCallback(fcb)
			357	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			358	+	}
			359	+	}
			360	+
			361	+	var DestroyDataVarRef uintptr
			362	+	if DestroyDataVar != nil {
			363	+	DestroyDataVarPtr := uintptr(unsafe.Pointer(DestroyDataVar))
			364	+	if cbRefPtr, ok := glib.GetCallback(DestroyDataVarPtr); ok {
			365	+	DestroyDataVarRef = cbRefPtr
			366	+	} else {
			367	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			368	+	cbFn := *DestroyDataVar
			369	+	cbFn(arg0, arg1)
			370	+	}
			371	+	DestroyDataVarRef = purego.NewCallback(fcb)
			372	+	glib.SaveCallback(DestroyDataVarPtr, DestroyDataVarRef)
			373	+	}
			374	+	}
			375	+
			376	+	cret := xSignalConnectData(InstanceVar.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, DestroyDataVarRef, ConnectFlagsVar)
317		return cret	377		return cret
318		}	378		}
319			379

@@ -634,7 +694,22 @@ var xSignalNew func(string, types.GType, SignalFlags, uint, uintptr, uintptr, ui
634		// be used.	694		// be used.
635		func SignalNew(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {	695		func SignalNew(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {
636			696
637	-	cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)	697	+	var AccumulatorVarRef uintptr
			698	+	if AccumulatorVar != nil {
			699	+	AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
			700	+	if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
			701	+	AccumulatorVarRef = cbRefPtr
			702	+	} else {
			703	+	fcb := func(arg0 SignalInvocationHint, arg1 Value, arg2 *Value, arg3 uintptr) bool {
			704	+	cbFn := *AccumulatorVar
			705	+	return cbFn(arg0, arg1, arg2, arg3)
			706	+	}
			707	+	AccumulatorVarRef = purego.NewCallback(fcb)
			708	+	glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
			709	+	}
			710	+	}
			711	+
			712	+	cret := xSignalNew(SignalNameVar, ItypeVar, SignalFlagsVar, ClassOffsetVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
638		return cret	713		return cret
639		}	714		}
640			715

@@ -658,7 +733,37 @@ var xSignalNewClassHandler func(string, types.GType, SignalFlags, uintptr, uintp
658		// the marshaller for this signal.	733		// the marshaller for this signal.
659		func SignalNewClassHandler(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassHandlerVar Callback, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {	734		func SignalNewClassHandler(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassHandlerVar Callback, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, varArgs ...interface{}) uint {
660			735
661	-	cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, glib.NewCallbackNullable(ClassHandlerVar), glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)	736	+	var ClassHandlerVarRef uintptr
			737	+	if ClassHandlerVar != nil {
			738	+	ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
			739	+	if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
			740	+	ClassHandlerVarRef = cbRefPtr
			741	+	} else {
			742	+	fcb := func() {
			743	+	cbFn := *ClassHandlerVar
			744	+	cbFn()
			745	+	}
			746	+	ClassHandlerVarRef = purego.NewCallback(fcb)
			747	+	glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
			748	+	}
			749	+	}
			750	+
			751	+	var AccumulatorVarRef uintptr
			752	+	if AccumulatorVar != nil {
			753	+	AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
			754	+	if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
			755	+	AccumulatorVarRef = cbRefPtr
			756	+	} else {
			757	+	fcb := func(arg0 SignalInvocationHint, arg1 Value, arg2 *Value, arg3 uintptr) bool {
			758	+	cbFn := *AccumulatorVar
			759	+	return cbFn(arg0, arg1, arg2, arg3)
			760	+	}
			761	+	AccumulatorVarRef = purego.NewCallback(fcb)
			762	+	glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
			763	+	}
			764	+	}
			765	+
			766	+	cret := xSignalNewClassHandler(SignalNameVar, ItypeVar, SignalFlagsVar, ClassHandlerVarRef, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, varArgs...)
662		return cret	767		return cret
663		}	768		}
664			769

@@ -672,7 +777,22 @@ var xSignalNewValist func(string, types.GType, SignalFlags, *Closure, uintptr, u
672		// the marshaller for this signal.	777		// the marshaller for this signal.
673		func SignalNewValist(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ArgsVar []interface{}) uint {	778		func SignalNewValist(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ArgsVar []interface{}) uint {
674			779
675	-	cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ArgsVar)	780	+	var AccumulatorVarRef uintptr
			781	+	if AccumulatorVar != nil {
			782	+	AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
			783	+	if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
			784	+	AccumulatorVarRef = cbRefPtr
			785	+	} else {
			786	+	fcb := func(arg0 SignalInvocationHint, arg1 Value, arg2 *Value, arg3 uintptr) bool {
			787	+	cbFn := *AccumulatorVar
			788	+	return cbFn(arg0, arg1, arg2, arg3)
			789	+	}
			790	+	AccumulatorVarRef = purego.NewCallback(fcb)
			791	+	glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
			792	+	}
			793	+	}
			794	+
			795	+	cret := xSignalNewValist(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ArgsVar)
676		return cret	796		return cret
677		}	797		}
678			798

@@ -686,7 +806,22 @@ var xSignalNewv func(string, types.GType, SignalFlags, *Closure, uintptr, uintpt
686		// the marshaller for this signal.	806		// the marshaller for this signal.
687		func SignalNewv(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ParamTypesVar []types.GType) uint {	807		func SignalNewv(SignalNameVar string, ItypeVar types.GType, SignalFlagsVar SignalFlags, ClassClosureVar Closure, AccumulatorVar SignalAccumulator, AccuDataVar uintptr, CMarshallerVar *SignalCMarshaller, ReturnTypeVar types.GType, NParamsVar uint, ParamTypesVar []types.GType) uint {
688			808
689	-	cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, glib.NewCallbackNullable(AccumulatorVar), AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ParamTypesVar)	809	+	var AccumulatorVarRef uintptr
			810	+	if AccumulatorVar != nil {
			811	+	AccumulatorVarPtr := uintptr(unsafe.Pointer(AccumulatorVar))
			812	+	if cbRefPtr, ok := glib.GetCallback(AccumulatorVarPtr); ok {
			813	+	AccumulatorVarRef = cbRefPtr
			814	+	} else {
			815	+	fcb := func(arg0 SignalInvocationHint, arg1 Value, arg2 *Value, arg3 uintptr) bool {
			816	+	cbFn := *AccumulatorVar
			817	+	return cbFn(arg0, arg1, arg2, arg3)
			818	+	}
			819	+	AccumulatorVarRef = purego.NewCallback(fcb)
			820	+	glib.SaveCallback(AccumulatorVarPtr, AccumulatorVarRef)
			821	+	}
			822	+	}
			823	+
			824	+	cret := xSignalNewv(SignalNameVar, ItypeVar, SignalFlagsVar, ClassClosureVar, AccumulatorVarRef, AccuDataVar, glib.NewCallbackNullable(CMarshallerVar), ReturnTypeVar, NParamsVar, ParamTypesVar)
690		return cret	825		return cret
691		}	826		}
692			827

@@ -717,7 +852,22 @@ var xSignalOverrideClassHandler func(string, types.GType, uintptr)
717		// parent class closure from inside the overridden one.	852		// parent class closure from inside the overridden one.
718		func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {	853		func SignalOverrideClassHandler(SignalNameVar string, InstanceTypeVar types.GType, ClassHandlerVar *Callback) {
719			854
720	-	xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, glib.NewCallback(ClassHandlerVar))	855	+	var ClassHandlerVarRef uintptr
			856	+	if ClassHandlerVar != nil {
			857	+	ClassHandlerVarPtr := uintptr(unsafe.Pointer(ClassHandlerVar))
			858	+	if cbRefPtr, ok := glib.GetCallback(ClassHandlerVarPtr); ok {
			859	+	ClassHandlerVarRef = cbRefPtr
			860	+	} else {
			861	+	fcb := func() {
			862	+	cbFn := *ClassHandlerVar
			863	+	cbFn()
			864	+	}
			865	+	ClassHandlerVarRef = purego.NewCallback(fcb)
			866	+	glib.SaveCallback(ClassHandlerVarPtr, ClassHandlerVarRef)
			867	+	}
			868	+	}
			869	+
			870	+	xSignalOverrideClassHandler(SignalNameVar, InstanceTypeVar, ClassHandlerVarRef)
721			871
722		}	872		}
723			873

M v4/gobject/gsignalgroup.go +95 -5


@@ -82,7 +82,22 @@ var xSignalGroupConnect func(uintptr, string, uintptr, uintptr)
82		// You cannot connect a signal handler after #GSignalGroup:target has been set.	82		// You cannot connect a signal handler after #GSignalGroup:target has been set.
83		func (x SignalGroup) Connect(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {	83		func (x SignalGroup) Connect(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
84			84
85	-	xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)	85	+	var CHandlerVarRef uintptr
			86	+	if CHandlerVar != nil {
			87	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			88	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			89	+	CHandlerVarRef = cbRefPtr
			90	+	} else {
			91	+	fcb := func() {
			92	+	cbFn := *CHandlerVar
			93	+	cbFn()
			94	+	}
			95	+	CHandlerVarRef = purego.NewCallback(fcb)
			96	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			97	+	}
			98	+	}
			99	+
			100	+	xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
86			101
87		}	102		}
88			103

@@ -96,7 +111,22 @@ var xSignalGroupConnectAfter func(uintptr, string, uintptr, uintptr)
96		// You cannot connect a signal handler after #GSignalGroup:target has been set.	111		// You cannot connect a signal handler after #GSignalGroup:target has been set.
97		func (x SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {	112		func (x SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
98			113
99	-	xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)	114	+	var CHandlerVarRef uintptr
			115	+	if CHandlerVar != nil {
			116	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			117	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			118	+	CHandlerVarRef = cbRefPtr
			119	+	} else {
			120	+	fcb := func() {
			121	+	cbFn := *CHandlerVar
			122	+	cbFn()
			123	+	}
			124	+	CHandlerVarRef = purego.NewCallback(fcb)
			125	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			126	+	}
			127	+	}
			128	+
			129	+	xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
100			130
101		}	131		}
102			132

@@ -119,7 +149,37 @@ var xSignalGroupConnectData func(uintptr, string, uintptr, uintptr, uintptr, Con
119		// You cannot connect a signal handler after #GSignalGroup:target has been set.	149		// You cannot connect a signal handler after #GSignalGroup:target has been set.
120		func (x SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {	150		func (x SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
121			151
122	-	xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar, glib.NewCallback(NotifyVar), FlagsVar)	152	+	var CHandlerVarRef uintptr
			153	+	if CHandlerVar != nil {
			154	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			155	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			156	+	CHandlerVarRef = cbRefPtr
			157	+	} else {
			158	+	fcb := func() {
			159	+	cbFn := *CHandlerVar
			160	+	cbFn()
			161	+	}
			162	+	CHandlerVarRef = purego.NewCallback(fcb)
			163	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			164	+	}
			165	+	}
			166	+
			167	+	var NotifyVarRef uintptr
			168	+	if NotifyVar != nil {
			169	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			170	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			171	+	NotifyVarRef = cbRefPtr
			172	+	} else {
			173	+	fcb := func(arg0 uintptr, arg1 *Closure) {
			174	+	cbFn := *NotifyVar
			175	+	cbFn(arg0, arg1)
			176	+	}
			177	+	NotifyVarRef = purego.NewCallback(fcb)
			178	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			179	+	}
			180	+	}
			181	+
			182	+	xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, NotifyVarRef, FlagsVar)
123			183
124		}	184		}
125			185

@@ -134,7 +194,22 @@ var xSignalGroupConnectObject func(uintptr, string, uintptr, uintptr, ConnectFla
134		// You cannot connect a signal handler after #GSignalGroup:target has been set.	194		// You cannot connect a signal handler after #GSignalGroup:target has been set.
135		func (x SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {	195		func (x SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
136			196
137	-	xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), ObjectVar, FlagsVar)	197	+	var CHandlerVarRef uintptr
			198	+	if CHandlerVar != nil {
			199	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			200	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			201	+	CHandlerVarRef = cbRefPtr
			202	+	} else {
			203	+	fcb := func() {
			204	+	cbFn := *CHandlerVar
			205	+	cbFn()
			206	+	}
			207	+	CHandlerVarRef = purego.NewCallback(fcb)
			208	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			209	+	}
			210	+	}
			211	+
			212	+	xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, ObjectVar, FlagsVar)
138			213
139		}	214		}
140			215

@@ -149,7 +224,22 @@ var xSignalGroupConnectSwapped func(uintptr, string, uintptr, uintptr)
149		// You cannot connect a signal handler after #GSignalGroup:target has been set.	224		// You cannot connect a signal handler after #GSignalGroup:target has been set.
150		func (x SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {	225		func (x SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar Callback, DataVar uintptr) {
151			226
152	-	xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, glib.NewCallback(CHandlerVar), DataVar)	227	+	var CHandlerVarRef uintptr
			228	+	if CHandlerVar != nil {
			229	+	CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
			230	+	if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
			231	+	CHandlerVarRef = cbRefPtr
			232	+	} else {
			233	+	fcb := func() {
			234	+	cbFn := *CHandlerVar
			235	+	cbFn()
			236	+	}
			237	+	CHandlerVarRef = purego.NewCallback(fcb)
			238	+	glib.SaveCallback(CHandlerVarPtr, CHandlerVarRef)
			239	+	}
			240	+	}
			241	+
			242	+	xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
153			243
154		}	244		}
155			245

M v4/gobject/gtype.go +95 -5


@@ -810,7 +810,22 @@ var xTypeAddClassCacheFunc func(uintptr, uintptr)
810		// chain.	810		// chain.
811		func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {	811		func TypeAddClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
812			812
813	-	xTypeAddClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))	813	+	var CacheFuncVarRef uintptr
			814	+	if CacheFuncVar != nil {
			815	+	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
			816	+	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
			817	+	CacheFuncVarRef = cbRefPtr
			818	+	} else {
			819	+	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
			820	+	cbFn := *CacheFuncVar
			821	+	return cbFn(arg0, arg1)
			822	+	}
			823	+	CacheFuncVarRef = purego.NewCallback(fcb)
			824	+	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
			825	+	}
			826	+	}
			827	+
			828	+	xTypeAddClassCacheFunc(CacheDataVar, CacheFuncVarRef)
814			829
815		}	830		}
816			831

@@ -853,7 +868,22 @@ var xTypeAddInterfaceCheck func(uintptr, uintptr)
853		// interfaces.	868		// interfaces.
854		func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {	869		func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
855			870
856	-	xTypeAddInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))	871	+	var CheckFuncVarRef uintptr
			872	+	if CheckFuncVar != nil {
			873	+	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
			874	+	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
			875	+	CheckFuncVarRef = cbRefPtr
			876	+	} else {
			877	+	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
			878	+	cbFn := *CheckFuncVar
			879	+	cbFn(arg0, arg1)
			880	+	}
			881	+	CheckFuncVarRef = purego.NewCallback(fcb)
			882	+	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
			883	+	}
			884	+	}
			885	+
			886	+	xTypeAddInterfaceCheck(CheckDataVar, CheckFuncVarRef)
857			887
858		}	888		}
859			889

@@ -1474,7 +1504,37 @@ var xTypeRegisterStaticSimple func(types.GType, string, uint, uintptr, uint, uin
1474		// struct and calling g_type_register_static().	1504		// struct and calling g_type_register_static().
1475		func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar ClassInitFunc, InstanceSizeVar uint, InstanceInitVar InstanceInitFunc, FlagsVar TypeFlags) types.GType {	1505		func TypeRegisterStaticSimple(ParentTypeVar types.GType, TypeNameVar string, ClassSizeVar uint, ClassInitVar ClassInitFunc, InstanceSizeVar uint, InstanceInitVar InstanceInitFunc, FlagsVar TypeFlags) types.GType {
1476			1506
1477	-	cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, glib.NewCallback(ClassInitVar), InstanceSizeVar, glib.NewCallback(InstanceInitVar), FlagsVar)	1507	+	var ClassInitVarRef uintptr
			1508	+	if ClassInitVar != nil {
			1509	+	ClassInitVarPtr := uintptr(unsafe.Pointer(ClassInitVar))
			1510	+	if cbRefPtr, ok := glib.GetCallback(ClassInitVarPtr); ok {
			1511	+	ClassInitVarRef = cbRefPtr
			1512	+	} else {
			1513	+	fcb := func(arg0 *TypeClass, arg1 uintptr) {
			1514	+	cbFn := *ClassInitVar
			1515	+	cbFn(arg0, arg1)
			1516	+	}
			1517	+	ClassInitVarRef = purego.NewCallback(fcb)
			1518	+	glib.SaveCallback(ClassInitVarPtr, ClassInitVarRef)
			1519	+	}
			1520	+	}
			1521	+
			1522	+	var InstanceInitVarRef uintptr
			1523	+	if InstanceInitVar != nil {
			1524	+	InstanceInitVarPtr := uintptr(unsafe.Pointer(InstanceInitVar))
			1525	+	if cbRefPtr, ok := glib.GetCallback(InstanceInitVarPtr); ok {
			1526	+	InstanceInitVarRef = cbRefPtr
			1527	+	} else {
			1528	+	fcb := func(arg0 TypeInstance, arg1 TypeClass) {
			1529	+	cbFn := *InstanceInitVar
			1530	+	cbFn(arg0, arg1)
			1531	+	}
			1532	+	InstanceInitVarRef = purego.NewCallback(fcb)
			1533	+	glib.SaveCallback(InstanceInitVarPtr, InstanceInitVarRef)
			1534	+	}
			1535	+	}
			1536	+
			1537	+	cret := xTypeRegisterStaticSimple(ParentTypeVar, TypeNameVar, ClassSizeVar, ClassInitVarRef, InstanceSizeVar, InstanceInitVarRef, FlagsVar)
1478		return cret	1538		return cret
1479		}	1539		}
1480			1540

@@ -1485,7 +1545,22 @@ var xTypeRemoveClassCacheFunc func(uintptr, uintptr)
1485		// g_type_remove_class_cache_func() to avoid leaks.	1545		// g_type_remove_class_cache_func() to avoid leaks.
1486		func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {	1546		func TypeRemoveClassCacheFunc(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc) {
1487			1547
1488	-	xTypeRemoveClassCacheFunc(CacheDataVar, glib.NewCallback(CacheFuncVar))	1548	+	var CacheFuncVarRef uintptr
			1549	+	if CacheFuncVar != nil {
			1550	+	CacheFuncVarPtr := uintptr(unsafe.Pointer(CacheFuncVar))
			1551	+	if cbRefPtr, ok := glib.GetCallback(CacheFuncVarPtr); ok {
			1552	+	CacheFuncVarRef = cbRefPtr
			1553	+	} else {
			1554	+	fcb := func(arg0 uintptr, arg1 *TypeClass) bool {
			1555	+	cbFn := *CacheFuncVar
			1556	+	return cbFn(arg0, arg1)
			1557	+	}
			1558	+	CacheFuncVarRef = purego.NewCallback(fcb)
			1559	+	glib.SaveCallback(CacheFuncVarPtr, CacheFuncVarRef)
			1560	+	}
			1561	+	}
			1562	+
			1563	+	xTypeRemoveClassCacheFunc(CacheDataVar, CacheFuncVarRef)
1489			1564
1490		}	1565		}
1491			1566

@@ -1495,7 +1570,22 @@ var xTypeRemoveInterfaceCheck func(uintptr, uintptr)
1495		// g_type_add_interface_check().	1570		// g_type_add_interface_check().
1496		func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {	1571		func TypeRemoveInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc) {
1497			1572
1498	-	xTypeRemoveInterfaceCheck(CheckDataVar, glib.NewCallback(CheckFuncVar))	1573	+	var CheckFuncVarRef uintptr
			1574	+	if CheckFuncVar != nil {
			1575	+	CheckFuncVarPtr := uintptr(unsafe.Pointer(CheckFuncVar))
			1576	+	if cbRefPtr, ok := glib.GetCallback(CheckFuncVarPtr); ok {
			1577	+	CheckFuncVarRef = cbRefPtr
			1578	+	} else {
			1579	+	fcb := func(arg0 uintptr, arg1 *TypeInterface) {
			1580	+	cbFn := *CheckFuncVar
			1581	+	cbFn(arg0, arg1)
			1582	+	}
			1583	+	CheckFuncVarRef = purego.NewCallback(fcb)
			1584	+	glib.SaveCallback(CheckFuncVarPtr, CheckFuncVarRef)
			1585	+	}
			1586	+	}
			1587	+
			1588	+	xTypeRemoveInterfaceCheck(CheckDataVar, CheckFuncVarRef)
1499			1589
1500		}	1590		}
1501			1591

M v4/gobject/gvalue.go +31 -16

 }
-var xValueSetInternedString func(uintptr, string)
+var xValueSetInternedString func(uintptr, uintptr)
 // Set the contents of a %G_TYPE_STRING #GValue to @v_string.  The string is
 // assumed to be static and interned (canonical, for example from
 // g_intern_string()), and is thus not duplicated when setting the #GValue.
-func (x *Value) SetInternedString(VStringVar string) {
+func (x *Value) SetInternedString(VStringVar *string) {
-	xValueSetInternedString(x.GoPointer(), VStringVar)
+	xValueSetInternedString(x.GoPointer(), core.NullableStringToPtr(VStringVar))
 }
 }
-var xValueSetStaticString func(uintptr, string)
+var xValueSetStaticString func(uintptr, uintptr)
 // Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 // The string is assumed to be static, and is thus not duplicated
 //
 // If the the string is a canonical string, using g_value_set_interned_string()
 // is more appropriate.
-func (x *Value) SetStaticString(VStringVar string) {
+func (x *Value) SetStaticString(VStringVar *string) {
-	xValueSetStaticString(x.GoPointer(), VStringVar)
+	xValueSetStaticString(x.GoPointer(), core.NullableStringToPtr(VStringVar))
 }
-var xValueSetString func(uintptr, string)
+var xValueSetString func(uintptr, uintptr)
 // Set the contents of a %G_TYPE_STRING #GValue to a copy of @v_string.
-func (x *Value) SetString(VStringVar string) {
+func (x *Value) SetString(VStringVar *string) {
-	xValueSetString(x.GoPointer(), VStringVar)
+	xValueSetString(x.GoPointer(), core.NullableStringToPtr(VStringVar))
 }
-var xValueSetStringTakeOwnership func(uintptr, string)
+var xValueSetStringTakeOwnership func(uintptr, uintptr)
 // This is an internal function introduced mainly for C marshallers.
-func (x *Value) SetStringTakeOwnership(VStringVar string) {
+func (x *Value) SetStringTakeOwnership(VStringVar *string) {
-	xValueSetStringTakeOwnership(x.GoPointer(), VStringVar)
+	xValueSetStringTakeOwnership(x.GoPointer(), core.NullableStringToPtr(VStringVar))
 }
 }
-var xValueTakeString func(uintptr, string)
+var xValueTakeString func(uintptr, uintptr)
 // Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
-func (x *Value) TakeString(VStringVar string) {
+func (x *Value) TakeString(VStringVar *string) {
-	xValueTakeString(x.GoPointer(), VStringVar)
+	xValueTakeString(x.GoPointer(), core.NullableStringToPtr(VStringVar))
 }
 // @dest_type will be replaced.
 func ValueRegisterTransformFunc(SrcTypeVar types.GType, DestTypeVar types.GType, TransformFuncVar *ValueTransform) {
-	xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, glib.NewCallback(TransformFuncVar))
+	var TransformFuncVarRef uintptr
+	if TransformFuncVar != nil {
+		TransformFuncVarPtr := uintptr(unsafe.Pointer(TransformFuncVar))
+		if cbRefPtr, ok := glib.GetCallback(TransformFuncVarPtr); ok {
+			TransformFuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 *Value, arg1 *Value) {
+				cbFn := *TransformFuncVar
+				cbFn(arg0, arg1)
+			}
+			TransformFuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(TransformFuncVarPtr, TransformFuncVarRef)
+		}
+	}
+	xValueRegisterTransformFunc(SrcTypeVar, DestTypeVar, TransformFuncVarRef)
 }

M v4/gobject/gvaluearray.go +32 -2


@@ -145,7 +145,22 @@ var xValueArraySort func(uintptr, uintptr) *ValueArray
145		// C qsort() function.	145		// C qsort() function.
146		func (x ValueArray) Sort(CompareFuncVar glib.CompareFunc) *ValueArray {	146		func (x ValueArray) Sort(CompareFuncVar glib.CompareFunc) *ValueArray {
147			147
148	-	cret := xValueArraySort(x.GoPointer(), glib.NewCallback(CompareFuncVar))	148	+	var CompareFuncVarRef uintptr
			149	+	if CompareFuncVar != nil {
			150	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			151	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
			152	+	CompareFuncVarRef = cbRefPtr
			153	+	} else {
			154	+	fcb := func(arg0 uintptr, arg1 uintptr) int {
			155	+	cbFn := *CompareFuncVar
			156	+	return cbFn(arg0, arg1)
			157	+	}
			158	+	CompareFuncVarRef = purego.NewCallback(fcb)
			159	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			160	+	}
			161	+	}
			162	+
			163	+	cret := xValueArraySort(x.GoPointer(), CompareFuncVarRef)
149		return cret	164		return cret
150		}	165		}
151			166

@@ -158,7 +173,22 @@ var xValueArraySortWithData func(uintptr, uintptr, uintptr) *ValueArray
158		// C qsort() function.	173		// C qsort() function.
159		func (x ValueArray) SortWithData(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {	174		func (x ValueArray) SortWithData(CompareFuncVar glib.CompareDataFunc, UserDataVar uintptr) *ValueArray {
160			175
161	-	cret := xValueArraySortWithData(x.GoPointer(), glib.NewCallback(CompareFuncVar), UserDataVar)	176	+	var CompareFuncVarRef uintptr
			177	+	if CompareFuncVar != nil {
			178	+	CompareFuncVarPtr := uintptr(unsafe.Pointer(CompareFuncVar))
			179	+	if cbRefPtr, ok := glib.GetCallback(CompareFuncVarPtr); ok {
			180	+	CompareFuncVarRef = cbRefPtr
			181	+	} else {
			182	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			183	+	cbFn := *CompareFuncVar
			184	+	return cbFn(arg0, arg1, arg2)
			185	+	}
			186	+	CompareFuncVarRef = purego.NewCallback(fcb)
			187	+	glib.SaveCallback(CompareFuncVarPtr, CompareFuncVarRef)
			188	+	}
			189	+	}
			190	+
			191	+	cret := xValueArraySortWithData(x.GoPointer(), CompareFuncVarRef, UserDataVar)
162		return cret	192		return cret
163		}	193		}
164			194

M v4/gsk/gskglshader.go +1 -1


@@ -585,7 +585,7 @@ func (c *GLShader) SetGoPointer(ptr uintptr) {
585		func (x *GLShader) SetPropertyResource(value string) {	585		func (x *GLShader) SetPropertyResource(value string) {
586		var v gobject.Value	586		var v gobject.Value
587		v.Init(gobject.TypeStringVal)	587		v.Init(gobject.TypeStringVal)
588	-	v.SetString(value)	588	+	v.SetString(&value)
589		x.SetProperty("resource", &v)	589		x.SetProperty("resource", &v)
590		}	590		}
591			591

M v4/gsk/gskrendernode.go +16 -1


@@ -298,7 +298,22 @@ var xRenderNodeDeserialize func(*glib.Bytes, uintptr, uintptr) uintptr
298		func RenderNodeDeserialize(BytesVar glib.Bytes, ErrorFuncVar ParseErrorFunc, UserDataVar uintptr) *RenderNode {	298		func RenderNodeDeserialize(BytesVar glib.Bytes, ErrorFuncVar ParseErrorFunc, UserDataVar uintptr) *RenderNode {
299		var cls *RenderNode	299		var cls *RenderNode
300			300
301	-	cret := xRenderNodeDeserialize(BytesVar, glib.NewCallbackNullable(ErrorFuncVar), UserDataVar)	301	+	var ErrorFuncVarRef uintptr
			302	+	if ErrorFuncVar != nil {
			303	+	ErrorFuncVarPtr := uintptr(unsafe.Pointer(ErrorFuncVar))
			304	+	if cbRefPtr, ok := glib.GetCallback(ErrorFuncVarPtr); ok {
			305	+	ErrorFuncVarRef = cbRefPtr
			306	+	} else {
			307	+	fcb := func(arg0 ParseLocation, arg1 ParseLocation, arg2 *glib.Error, arg3 uintptr) {
			308	+	cbFn := *ErrorFuncVar
			309	+	cbFn(arg0, arg1, arg2, arg3)
			310	+	}
			311	+	ErrorFuncVarRef = purego.NewCallback(fcb)
			312	+	glib.SaveCallback(ErrorFuncVarPtr, ErrorFuncVarRef)
			313	+	}
			314	+	}
			315	+
			316	+	cret := xRenderNodeDeserialize(BytesVar, ErrorFuncVarRef, UserDataVar)
302			317
303		if cret == 0 {	318		if cret == 0 {
304		return nil	319		return nil

M v4/gsk/gsktypes.go +32 -2


@@ -247,7 +247,22 @@ var xPathForeach func(uintptr, PathForeachFlags, uintptr, uintptr) bool
247		// an approximation of the path using just the allowed operations.	247		// an approximation of the path using just the allowed operations.
248		func (x Path) Foreach(FlagsVar PathForeachFlags, FuncVar PathForeachFunc, UserDataVar uintptr) bool {	248		func (x Path) Foreach(FlagsVar PathForeachFlags, FuncVar PathForeachFunc, UserDataVar uintptr) bool {
249			249
250	-	cret := xPathForeach(x.GoPointer(), FlagsVar, glib.NewCallback(FuncVar), UserDataVar)	250	+	var FuncVarRef uintptr
			251	+	if FuncVar != nil {
			252	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			253	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			254	+	FuncVarRef = cbRefPtr
			255	+	} else {
			256	+	fcb := func(arg0 PathOperation, arg1 []graphene.Point, arg2 uint, arg3 float32, arg4 uintptr) bool {
			257	+	cbFn := *FuncVar
			258	+	return cbFn(arg0, arg1, arg2, arg3, arg4)
			259	+	}
			260	+	FuncVarRef = purego.NewCallback(fcb)
			261	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			262	+	}
			263	+	}
			264	+
			265	+	cret := xPathForeach(x.GoPointer(), FlagsVar, FuncVarRef, UserDataVar)
251		return cret	266		return cret
252		}	267		}
253			268

@@ -270,7 +285,22 @@ var xPathForeachIntersection func(uintptr, *Path, uintptr, uintptr) bool
270		// If @func returns `FALSE`, the iteration is stopped.	285		// If @func returns `FALSE`, the iteration is stopped.
271		func (x Path) ForeachIntersection(Path2Var Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {	286		func (x Path) ForeachIntersection(Path2Var Path, FuncVar *PathIntersectionFunc, UserDataVar uintptr) bool {
272			287
273	-	cret := xPathForeachIntersection(x.GoPointer(), Path2Var, glib.NewCallback(FuncVar), UserDataVar)	288	+	var FuncVarRef uintptr
			289	+	if FuncVar != nil {
			290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			291	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			292	+	FuncVarRef = cbRefPtr
			293	+	} else {
			294	+	fcb := func(arg0 Path, arg1 PathPoint, arg2 Path, arg3 PathPoint, arg4 PathIntersection, arg5 uintptr) bool {
			295	+	cbFn := *FuncVar
			296	+	return cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
			297	+	}
			298	+	FuncVarRef = purego.NewCallback(fcb)
			299	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			300	+	}
			301	+	}
			302	+
			303	+	cret := xPathForeachIntersection(x.GoPointer(), Path2Var, FuncVarRef, UserDataVar)
274		return cret	304		return cret
275		}	305		}
276			306

M v4/gtk/gtkaboutdialog.go +37 -37


@@ -357,25 +357,25 @@ func (x *AboutDialog) SetAuthors(AuthorsVar []string) {
357			357
358		}	358		}
359			359
360	-	var xAboutDialogSetComments func(uintptr, string)	360	+	var xAboutDialogSetComments func(uintptr, uintptr)
361			361
362		// Sets the comments string to display in the about dialog.	362		// Sets the comments string to display in the about dialog.
363		//	363		//
364		// This should be a short string of one or two lines.	364		// This should be a short string of one or two lines.
365	-	func (x *AboutDialog) SetComments(CommentsVar string) {	365	+	func (x AboutDialog) SetComments(CommentsVar string) {
366			366
367	-	xAboutDialogSetComments(x.GoPointer(), CommentsVar)	367	+	xAboutDialogSetComments(x.GoPointer(), core.NullableStringToPtr(CommentsVar))
368			368
369		}	369		}
370			370
371	-	var xAboutDialogSetCopyright func(uintptr, string)	371	+	var xAboutDialogSetCopyright func(uintptr, uintptr)
372			372
373		// Sets the copyright string to display in the about dialog.	373		// Sets the copyright string to display in the about dialog.
374		//	374		//
375		// This should be a short string of one or two lines.	375		// This should be a short string of one or two lines.
376	-	func (x *AboutDialog) SetCopyright(CopyrightVar string) {	376	+	func (x AboutDialog) SetCopyright(CopyrightVar string) {
377			377
378	-	xAboutDialogSetCopyright(x.GoPointer(), CopyrightVar)	378	+	xAboutDialogSetCopyright(x.GoPointer(), core.NullableStringToPtr(CopyrightVar))
379			379
380		}	380		}
381			381

@@ -389,15 +389,15 @@ func (x *AboutDialog) SetDocumenters(DocumentersVar []string) {
389			389
390		}	390		}
391			391
392	-	var xAboutDialogSetLicense func(uintptr, string)	392	+	var xAboutDialogSetLicense func(uintptr, uintptr)
393			393
394		// Sets the license information to be displayed in the	394		// Sets the license information to be displayed in the
395		// about dialog.	395		// about dialog.
396		//	396		//
397		// If `license` is `NULL`, the license page is hidden.	397		// If `license` is `NULL`, the license page is hidden.
398	-	func (x *AboutDialog) SetLicense(LicenseVar string) {	398	+	func (x AboutDialog) SetLicense(LicenseVar string) {
399			399
400	-	xAboutDialogSetLicense(x.GoPointer(), LicenseVar)	400	+	xAboutDialogSetLicense(x.GoPointer(), core.NullableStringToPtr(LicenseVar))
401			401
402		}	402		}
403			403

@@ -423,28 +423,28 @@ func (x *AboutDialog) SetLogo(LogoVar gdk.Paintable) {
423			423
424		}	424		}
425			425
426	-	var xAboutDialogSetLogoIconName func(uintptr, string)	426	+	var xAboutDialogSetLogoIconName func(uintptr, uintptr)
427			427
428		// Sets the icon name to be displayed as logo in the about dialog.	428		// Sets the icon name to be displayed as logo in the about dialog.
429	-	func (x *AboutDialog) SetLogoIconName(IconNameVar string) {	429	+	func (x AboutDialog) SetLogoIconName(IconNameVar string) {
430			430
431	-	xAboutDialogSetLogoIconName(x.GoPointer(), IconNameVar)	431	+	xAboutDialogSetLogoIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
432			432
433		}	433		}
434			434
435	-	var xAboutDialogSetProgramName func(uintptr, string)	435	+	var xAboutDialogSetProgramName func(uintptr, uintptr)
436			436
437		// Sets the name to display in the about dialog.	437		// Sets the name to display in the about dialog.
438		//	438		//
439		// If `name` is not set, the string returned	439		// If `name` is not set, the string returned
440		// by `g_get_application_name()` is used.	440		// by `g_get_application_name()` is used.
441	-	func (x *AboutDialog) SetProgramName(NameVar string) {	441	+	func (x AboutDialog) SetProgramName(NameVar string) {
442			442
443	-	xAboutDialogSetProgramName(x.GoPointer(), NameVar)	443	+	xAboutDialogSetProgramName(x.GoPointer(), core.NullableStringToPtr(NameVar))
444			444
445		}	445		}
446			446
447	-	var xAboutDialogSetSystemInformation func(uintptr, string)	447	+	var xAboutDialogSetSystemInformation func(uintptr, uintptr)
448			448
449		// Sets the system information to be displayed in the about	449		// Sets the system information to be displayed in the about
450		// dialog.	450		// dialog.

@@ -453,13 +453,13 @@ var xAboutDialogSetSystemInformation func(uintptr, string)
453		// page is hidden.	453		// page is hidden.
454		//	454		//
455		// See [property@Gtk.AboutDialog:system-information].	455		// See [property@Gtk.AboutDialog:system-information].
456	-	func (x *AboutDialog) SetSystemInformation(SystemInformationVar string) {	456	+	func (x AboutDialog) SetSystemInformation(SystemInformationVar string) {
457			457
458	-	xAboutDialogSetSystemInformation(x.GoPointer(), SystemInformationVar)	458	+	xAboutDialogSetSystemInformation(x.GoPointer(), core.NullableStringToPtr(SystemInformationVar))
459			459
460		}	460		}
461			461
462	-	var xAboutDialogSetTranslatorCredits func(uintptr, string)	462	+	var xAboutDialogSetTranslatorCredits func(uintptr, uintptr)
463			463
464		// Sets the translator credits string which is displayed in	464		// Sets the translator credits string which is displayed in
465		// the credits page.	465		// the credits page.

@@ -481,27 +481,27 @@ var xAboutDialogSetTranslatorCredits func(uintptr, string)
481		// for this purpose, since translators will already know the purpose of	481		// for this purpose, since translators will already know the purpose of
482		// that `msgid`, and since `GtkAboutDialog` will detect if “translator-credits”	482		// that `msgid`, and since `GtkAboutDialog` will detect if “translator-credits”
483		// is untranslated and omit translator credits.	483		// is untranslated and omit translator credits.
484	-	func (x *AboutDialog) SetTranslatorCredits(TranslatorCreditsVar string) {	484	+	func (x AboutDialog) SetTranslatorCredits(TranslatorCreditsVar string) {
485			485
486	-	xAboutDialogSetTranslatorCredits(x.GoPointer(), TranslatorCreditsVar)	486	+	xAboutDialogSetTranslatorCredits(x.GoPointer(), core.NullableStringToPtr(TranslatorCreditsVar))
487			487
488		}	488		}
489			489
490	-	var xAboutDialogSetVersion func(uintptr, string)	490	+	var xAboutDialogSetVersion func(uintptr, uintptr)
491			491
492		// Sets the version string to display in the about dialog.	492		// Sets the version string to display in the about dialog.
493	-	func (x *AboutDialog) SetVersion(VersionVar string) {	493	+	func (x AboutDialog) SetVersion(VersionVar string) {
494			494
495	-	xAboutDialogSetVersion(x.GoPointer(), VersionVar)	495	+	xAboutDialogSetVersion(x.GoPointer(), core.NullableStringToPtr(VersionVar))
496			496
497		}	497		}
498			498
499	-	var xAboutDialogSetWebsite func(uintptr, string)	499	+	var xAboutDialogSetWebsite func(uintptr, uintptr)
500			500
501		// Sets the URL to use for the website link.	501		// Sets the URL to use for the website link.
502	-	func (x *AboutDialog) SetWebsite(WebsiteVar string) {	502	+	func (x AboutDialog) SetWebsite(WebsiteVar string) {
503			503
504	-	xAboutDialogSetWebsite(x.GoPointer(), WebsiteVar)	504	+	xAboutDialogSetWebsite(x.GoPointer(), core.NullableStringToPtr(WebsiteVar))
505			505
506		}	506		}
507			507

@@ -590,7 +590,7 @@ func (x *AboutDialog) GetPropertyAuthors() []string {
590		func (x *AboutDialog) SetPropertyComments(value string) {	590		func (x *AboutDialog) SetPropertyComments(value string) {
591		var v gobject.Value	591		var v gobject.Value
592		v.Init(gobject.TypeStringVal)	592		v.Init(gobject.TypeStringVal)
593	-	v.SetString(value)	593	+	v.SetString(&value)
594		x.SetProperty("comments", &v)	594		x.SetProperty("comments", &v)
595		}	595		}
596			596

@@ -611,7 +611,7 @@ func (x *AboutDialog) GetPropertyComments() string {
611		func (x *AboutDialog) SetPropertyCopyright(value string) {	611		func (x *AboutDialog) SetPropertyCopyright(value string) {
612		var v gobject.Value	612		var v gobject.Value
613		v.Init(gobject.TypeStringVal)	613		v.Init(gobject.TypeStringVal)
614	-	v.SetString(value)	614	+	v.SetString(&value)
615		x.SetProperty("copyright", &v)	615		x.SetProperty("copyright", &v)
616		}	616		}
617			617

@@ -664,7 +664,7 @@ func (x *AboutDialog) GetPropertyDocumenters() []string {
664		func (x *AboutDialog) SetPropertyLicense(value string) {	664		func (x *AboutDialog) SetPropertyLicense(value string) {
665		var v gobject.Value	665		var v gobject.Value
666		v.Init(gobject.TypeStringVal)	666		v.Init(gobject.TypeStringVal)
667	-	v.SetString(value)	667	+	v.SetString(&value)
668		x.SetProperty("license", &v)	668		x.SetProperty("license", &v)
669		}	669		}
670			670

@@ -696,7 +696,7 @@ func (x *AboutDialog) GetPropertyLicense() string {
696		func (x *AboutDialog) SetPropertyLogoIconName(value string) {	696		func (x *AboutDialog) SetPropertyLogoIconName(value string) {
697		var v gobject.Value	697		var v gobject.Value
698		v.Init(gobject.TypeStringVal)	698		v.Init(gobject.TypeStringVal)
699	-	v.SetString(value)	699	+	v.SetString(&value)
700		x.SetProperty("logo-icon-name", &v)	700		x.SetProperty("logo-icon-name", &v)
701		}	701		}
702			702

@@ -718,7 +718,7 @@ func (x *AboutDialog) GetPropertyLogoIconName() string {
718		func (x *AboutDialog) SetPropertyProgramName(value string) {	718		func (x *AboutDialog) SetPropertyProgramName(value string) {
719		var v gobject.Value	719		var v gobject.Value
720		v.Init(gobject.TypeStringVal)	720		v.Init(gobject.TypeStringVal)
721	-	v.SetString(value)	721	+	v.SetString(&value)
722		x.SetProperty("program-name", &v)	722		x.SetProperty("program-name", &v)
723		}	723		}
724			724

@@ -746,7 +746,7 @@ func (x *AboutDialog) GetPropertyProgramName() string {
746		func (x *AboutDialog) SetPropertySystemInformation(value string) {	746		func (x *AboutDialog) SetPropertySystemInformation(value string) {
747		var v gobject.Value	747		var v gobject.Value
748		v.Init(gobject.TypeStringVal)	748		v.Init(gobject.TypeStringVal)
749	-	v.SetString(value)	749	+	v.SetString(&value)
750		x.SetProperty("system-information", &v)	750		x.SetProperty("system-information", &v)
751		}	751		}
752			752

@@ -776,7 +776,7 @@ func (x *AboutDialog) GetPropertySystemInformation() string {
776		func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {	776		func (x *AboutDialog) SetPropertyTranslatorCredits(value string) {
777		var v gobject.Value	777		var v gobject.Value
778		v.Init(gobject.TypeStringVal)	778		v.Init(gobject.TypeStringVal)
779	-	v.SetString(value)	779	+	v.SetString(&value)
780		x.SetProperty("translator-credits", &v)	780		x.SetProperty("translator-credits", &v)
781		}	781		}
782			782

@@ -798,7 +798,7 @@ func (x *AboutDialog) GetPropertyTranslatorCredits() string {
798		func (x *AboutDialog) SetPropertyVersion(value string) {	798		func (x *AboutDialog) SetPropertyVersion(value string) {
799		var v gobject.Value	799		var v gobject.Value
800		v.Init(gobject.TypeStringVal)	800		v.Init(gobject.TypeStringVal)
801	-	v.SetString(value)	801	+	v.SetString(&value)
802		x.SetProperty("version", &v)	802		x.SetProperty("version", &v)
803		}	803		}
804			804

@@ -817,7 +817,7 @@ func (x *AboutDialog) GetPropertyVersion() string {
817		func (x *AboutDialog) SetPropertyWebsite(value string) {	817		func (x *AboutDialog) SetPropertyWebsite(value string) {
818		var v gobject.Value	818		var v gobject.Value
819		v.Init(gobject.TypeStringVal)	819		v.Init(gobject.TypeStringVal)
820	-	v.SetString(value)	820	+	v.SetString(&value)
821		x.SetProperty("website", &v)	821		x.SetProperty("website", &v)
822		}	822		}
823			823

@@ -836,7 +836,7 @@ func (x *AboutDialog) GetPropertyWebsite() string {
836		func (x *AboutDialog) SetPropertyWebsiteLabel(value string) {	836		func (x *AboutDialog) SetPropertyWebsiteLabel(value string) {
837		var v gobject.Value	837		var v gobject.Value
838		v.Init(gobject.TypeStringVal)	838		v.Init(gobject.TypeStringVal)
839	-	v.SetString(value)	839	+	v.SetString(&value)
840		x.SetProperty("website-label", &v)	840		x.SetProperty("website-label", &v)
841		}	841		}
842			842

M v4/gtk/gtkactionable.go +5 -5


@@ -148,7 +148,7 @@ type Actionable interface {
148		SetGoPointer(uintptr)	148		SetGoPointer(uintptr)
149		GetActionName() string	149		GetActionName() string
150		GetActionTargetValue() *glib.Variant	150		GetActionTargetValue() *glib.Variant
151	-	SetActionName(ActionNameVar string)	151	+	SetActionName(ActionNameVar *string)
152		SetActionTarget(FormatStringVar string, varArgs ...interface{})	152		SetActionTarget(FormatStringVar string, varArgs ...interface{})
153		SetActionTargetValue(TargetValueVar *glib.Variant)	153		SetActionTargetValue(TargetValueVar *glib.Variant)
154		SetDetailedActionName(DetailedActionNameVar string)	154		SetDetailedActionName(DetailedActionNameVar string)

@@ -202,9 +202,9 @@ func (x ActionableBase) GetActionTargetValue() glib.Variant {
202		// containing [class@ApplicationWindow] or its associated [class@Application],	202		// containing [class@ApplicationWindow] or its associated [class@Application],
203		// respectively. This is the same form used for actions in the [class@Gio.Menu]	203		// respectively. This is the same form used for actions in the [class@Gio.Menu]
204		// associated with the window.	204		// associated with the window.
205	-	func (x *ActionableBase) SetActionName(ActionNameVar string) {	205	+	func (x ActionableBase) SetActionName(ActionNameVar string) {
206			206
207	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	207	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
208			208
209		}	209		}
210			210

@@ -265,7 +265,7 @@ func (x *ActionableBase) SetPropertyActionName(value string) {
265		obj.Ptr = x.GoPointer()	265		obj.Ptr = x.GoPointer()
266		var v gobject.Value	266		var v gobject.Value
267		v.Init(gobject.TypeStringVal)	267		v.Init(gobject.TypeStringVal)
268	-	v.SetString(value)	268	+	v.SetString(&value)
269		obj.SetProperty("action-name", &v)	269		obj.SetProperty("action-name", &v)
270		}	270		}
271			271

@@ -302,7 +302,7 @@ func (x *ActionableBase) GetPropertyActionTarget() uintptr {
302			302
303		var XGtkActionableGetActionName func(uintptr) string	303		var XGtkActionableGetActionName func(uintptr) string
304		var XGtkActionableGetActionTargetValue func(uintptr) *glib.Variant	304		var XGtkActionableGetActionTargetValue func(uintptr) *glib.Variant
305	-	var XGtkActionableSetActionName func(uintptr, string)	305	+	var XGtkActionableSetActionName func(uintptr, uintptr)
306		var XGtkActionableSetActionTarget func(uintptr, string, ...interface{})	306		var XGtkActionableSetActionTarget func(uintptr, string, ...interface{})
307		var XGtkActionableSetActionTargetValue func(uintptr, *glib.Variant)	307		var XGtkActionableSetActionTargetValue func(uintptr, *glib.Variant)
308		var XGtkActionableSetDetailedActionName func(uintptr, string)	308		var XGtkActionableSetDetailedActionName func(uintptr, string)

M v4/gtk/gtkalertdialog.go +18 -3

 // this case is [method@Gtk.AlertDialog.show].
 func (x *AlertDialog) Choose(ParentVar *Window, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
-	xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
+	var CallbackVarRef uintptr
+	if CallbackVar != nil {
+		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
+		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
+			CallbackVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
+				cbFn := *CallbackVar
+				cbFn(arg0, arg1, arg2)
+			}
+			CallbackVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
+		}
+	}
+	xAlertDialogChoose(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
 }
 func (x *AlertDialog) SetPropertyDetail(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("detail", &v)
 }
 func (x *AlertDialog) SetPropertyMessage(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("message", &v)
 }

M v4/gtk/gtkappchooser.go +1 -1


@@ -95,7 +95,7 @@ func (x *AppChooserBase) SetPropertyContentType(value string) {
95		obj.Ptr = x.GoPointer()	95		obj.Ptr = x.GoPointer()
96		var v gobject.Value	96		var v gobject.Value
97		v.Init(gobject.TypeStringVal)	97		v.Init(gobject.TypeStringVal)
98	-	v.SetString(value)	98	+	v.SetString(&value)
99		obj.SetProperty("content-type", &v)	99		obj.SetProperty("content-type", &v)
100		}	100		}
101			101

M v4/gtk/gtkappchooserbutton.go +24 -1


@@ -2,6 +2,7 @@
2		package gtk	2		package gtk
3			3
4		import (	4		import (
			5	+	"fmt"
5		"unsafe"	6		"unsafe"
6			7
7		"github.com/jwijenbergh/purego"	8		"github.com/jwijenbergh/purego"

@@ -216,7 +217,7 @@ func (c *AppChooserButton) SetGoPointer(ptr uintptr) {
216		func (x *AppChooserButton) SetPropertyHeading(value string) {	217		func (x *AppChooserButton) SetPropertyHeading(value string) {
217		var v gobject.Value	218		var v gobject.Value
218		v.Init(gobject.TypeStringVal)	219		v.Init(gobject.TypeStringVal)
219	-	v.SetString(value)	220	+	v.SetString(&value)
220		x.SetProperty("heading", &v)	221		x.SetProperty("heading", &v)
221		}	222		}
222			223

@@ -352,6 +353,28 @@ func (x AppChooserButton) ConnectCustomItemActivated(cb func(AppChooserButton,
352		return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)	353		return gobject.SignalConnect(x.GoPointer(), "custom-item-activated", cbRefPtr)
353		}	354		}
354			355
			356	+	// ConnectCustomItemActivatedWithDetail connects to the "custom-item-activated" signal with a detail string.
			357	+	// The detail is appended as "custom-item-activated::<detail>".
			358	+	func (x AppChooserButton) ConnectCustomItemActivatedWithDetail(detail string, cb func(AppChooserButton, string)) uint32 {
			359	+	cbPtr := uintptr(unsafe.Pointer(cb))
			360	+	signalName := fmt.Sprintf("custom-item-activated::%s", detail)
			361	+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
			362	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			363	+	}
			364	+
			365	+	fcb := func(clsPtr uintptr, ItemNameVarp string) {
			366	+	fa := AppChooserButton{}
			367	+	fa.Ptr = clsPtr
			368	+	cbFn := *cb
			369	+
			370	+	cbFn(fa, ItemNameVarp)
			371	+
			372	+	}
			373	+	cbRefPtr := purego.NewCallback(fcb)
			374	+	glib.SaveCallback(cbPtr, cbRefPtr)
			375	+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
			376	+	}
			377	+
355		// Requests the user's screen reader to announce the given message.	378		// Requests the user's screen reader to announce the given message.
356		//	379		//
357		// This kind of notification is useful for messages that	380		// This kind of notification is useful for messages that

M v4/gtk/gtkappchooserdialog.go +1 -1


@@ -142,7 +142,7 @@ func (c *AppChooserDialog) SetGoPointer(ptr uintptr) {
142		func (x *AppChooserDialog) SetPropertyHeading(value string) {	142		func (x *AppChooserDialog) SetPropertyHeading(value string) {
143		var v gobject.Value	143		var v gobject.Value
144		v.Init(gobject.TypeStringVal)	144		v.Init(gobject.TypeStringVal)
145	-	v.SetString(value)	145	+	v.SetString(&value)
146		x.SetProperty("heading", &v)	146		x.SetProperty("heading", &v)
147		}	147		}
148			148

M v4/gtk/gtkappchooserwidget.go +1 -1


@@ -206,7 +206,7 @@ func (c *AppChooserWidget) SetGoPointer(ptr uintptr) {
206		func (x *AppChooserWidget) SetPropertyDefaultText(value string) {	206		func (x *AppChooserWidget) SetPropertyDefaultText(value string) {
207		var v gobject.Value	207		var v gobject.Value
208		v.Init(gobject.TypeStringVal)	208		v.Init(gobject.TypeStringVal)
209	-	v.SetString(value)	209	+	v.SetString(&value)
210		x.SetProperty("default-text", &v)	210		x.SetProperty("default-text", &v)
211		}	211		}
212			212

M v4/gtk/gtkapplication.go +6 -6


@@ -199,7 +199,7 @@ func ApplicationNewFromInternalPtr(ptr uintptr) *Application {
199		return cls	199		return cls
200		}	200		}
201			201
202	-	var xNewApplication func(string, gio.ApplicationFlags) uintptr	202	+	var xNewApplication func(uintptr, gio.ApplicationFlags) uintptr
203			203
204		// Creates a new application instance.	204		// Creates a new application instance.
205		//	205		//

@@ -219,10 +219,10 @@ var xNewApplication func(string, gio.ApplicationFlags) uintptr
219		//	219		//
220		// If no application ID is given then some features (most notably application	220		// If no application ID is given then some features (most notably application
221		// uniqueness) will be disabled.	221		// uniqueness) will be disabled.
222	-	func NewApplication(ApplicationIdVar string, FlagsVar gio.ApplicationFlags) *Application {	222	+	func NewApplication(ApplicationIdVar string, FlagsVar gio.ApplicationFlags) Application {
223		var cls *Application	223		var cls *Application
224			224
225	-	cret := xNewApplication(ApplicationIdVar, FlagsVar)	225	+	cret := xNewApplication(core.NullableStringToPtr(ApplicationIdVar), FlagsVar)
226			226
227		if cret == 0 {	227		if cret == 0 {
228		return nil	228		return nil

@@ -385,7 +385,7 @@ func (x Application) GetWindows() glib.List {
385		return cret	385		return cret
386		}	386		}
387			387
388	-	var xApplicationInhibit func(uintptr, uintptr, ApplicationInhibitFlags, string) uint	388	+	var xApplicationInhibit func(uintptr, uintptr, ApplicationInhibitFlags, uintptr) uint
389			389
390		// Informs the session manager that certain types of actions should be	390		// Informs the session manager that certain types of actions should be
391		// inhibited.	391		// inhibited.

@@ -414,9 +414,9 @@ var xApplicationInhibit func(uintptr, uintptr, ApplicationInhibitFlags, string)
414		// The cookie that is returned by this function should be used as an	414		// The cookie that is returned by this function should be used as an
415		// argument to [method@Gtk.Application.uninhibit] in order to remove	415		// argument to [method@Gtk.Application.uninhibit] in order to remove
416		// the request.	416		// the request.
417	-	func (x Application) Inhibit(WindowVar Window, FlagsVar ApplicationInhibitFlags, ReasonVar string) uint {	417	+	func (x Application) Inhibit(WindowVar Window, FlagsVar ApplicationInhibitFlags, ReasonVar *string) uint {
418			418
419	-	cret := xApplicationInhibit(x.GoPointer(), WindowVar.GoPointer(), FlagsVar, ReasonVar)	419	+	cret := xApplicationInhibit(x.GoPointer(), WindowVar.GoPointer(), FlagsVar, core.NullableStringToPtr(ReasonVar))
420		return cret	420		return cret
421		}	421		}
422			422

M v4/gtk/gtkassistant.go +32 -2


@@ -360,7 +360,37 @@ var xAssistantSetForwardPageFunc func(uintptr, uintptr, uintptr, uintptr)
360		// next visible page.	360		// next visible page.
361		func (x Assistant) SetForwardPageFunc(PageFuncVar AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {	361		func (x Assistant) SetForwardPageFunc(PageFuncVar AssistantPageFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
362			362
363	-	xAssistantSetForwardPageFunc(x.GoPointer(), glib.NewCallbackNullable(PageFuncVar), DataVar, glib.NewCallback(DestroyVar))	363	+	var PageFuncVarRef uintptr
			364	+	if PageFuncVar != nil {
			365	+	PageFuncVarPtr := uintptr(unsafe.Pointer(PageFuncVar))
			366	+	if cbRefPtr, ok := glib.GetCallback(PageFuncVarPtr); ok {
			367	+	PageFuncVarRef = cbRefPtr
			368	+	} else {
			369	+	fcb := func(arg0 int, arg1 uintptr) int {
			370	+	cbFn := *PageFuncVar
			371	+	return cbFn(arg0, arg1)
			372	+	}
			373	+	PageFuncVarRef = purego.NewCallback(fcb)
			374	+	glib.SaveCallback(PageFuncVarPtr, PageFuncVarRef)
			375	+	}
			376	+	}
			377	+
			378	+	var DestroyVarRef uintptr
			379	+	if DestroyVar != nil {
			380	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			381	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			382	+	DestroyVarRef = cbRefPtr
			383	+	} else {
			384	+	fcb := func(arg0 uintptr) {
			385	+	cbFn := *DestroyVar
			386	+	cbFn(arg0)
			387	+	}
			388	+	DestroyVarRef = purego.NewCallback(fcb)
			389	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			390	+	}
			391	+	}
			392	+
			393	+	xAssistantSetForwardPageFunc(x.GoPointer(), PageFuncVarRef, DataVar, DestroyVarRef)
364			394
365		}	395		}
366			396

@@ -1026,7 +1056,7 @@ func (x *AssistantPage) GetPropertyComplete() bool {
1026		func (x *AssistantPage) SetPropertyTitle(value string) {	1056		func (x *AssistantPage) SetPropertyTitle(value string) {
1027		var v gobject.Value	1057		var v gobject.Value
1028		v.Init(gobject.TypeStringVal)	1058		v.Init(gobject.TypeStringVal)
1029	-	v.SetString(value)	1059	+	v.SetString(&value)
1030		x.SetProperty("title", &v)	1060		x.SetProperty("title", &v)
1031		}	1061		}
1032			1062

M v4/gtk/gtkbookmarklist.go +8 -8


@@ -46,13 +46,13 @@ func BookmarkListNewFromInternalPtr(ptr uintptr) *BookmarkList {
46		return cls	46		return cls
47		}	47		}
48			48
49	-	var xNewBookmarkList func(string, string) uintptr	49	+	var xNewBookmarkList func(uintptr, uintptr) uintptr
50			50
51		// Creates a new `GtkBookmarkList` with the given @attributes.	51		// Creates a new `GtkBookmarkList` with the given @attributes.
52	-	func NewBookmarkList(FilenameVar string, AttributesVar string) *BookmarkList {	52	+	func NewBookmarkList(FilenameVar string, AttributesVar string) *BookmarkList {
53		var cls *BookmarkList	53		var cls *BookmarkList
54			54
55	-	cret := xNewBookmarkList(FilenameVar, AttributesVar)	55	+	cret := xNewBookmarkList(core.NullableStringToPtr(FilenameVar), core.NullableStringToPtr(AttributesVar))
56			56
57		if cret == 0 {	57		if cret == 0 {
58		return nil	58		return nil

@@ -103,15 +103,15 @@ func (x *BookmarkList) IsLoading() bool {
103		return cret	103		return cret
104		}	104		}
105			105
106	-	var xBookmarkListSetAttributes func(uintptr, string)	106	+	var xBookmarkListSetAttributes func(uintptr, uintptr)
107			107
108		// Sets the @attributes to be enumerated and starts the enumeration.	108		// Sets the @attributes to be enumerated and starts the enumeration.
109		//	109		//
110		// If @attributes is %NULL, no attributes will be queried, but a list	110		// If @attributes is %NULL, no attributes will be queried, but a list
111		// of `GFileInfo`s will still be created.	111		// of `GFileInfo`s will still be created.
112	-	func (x *BookmarkList) SetAttributes(AttributesVar string) {	112	+	func (x BookmarkList) SetAttributes(AttributesVar string) {
113			113
114	-	xBookmarkListSetAttributes(x.GoPointer(), AttributesVar)	114	+	xBookmarkListSetAttributes(x.GoPointer(), core.NullableStringToPtr(AttributesVar))
115			115
116		}	116		}
117			117

@@ -142,7 +142,7 @@ func (c *BookmarkList) SetGoPointer(ptr uintptr) {
142		func (x *BookmarkList) SetPropertyAttributes(value string) {	142		func (x *BookmarkList) SetPropertyAttributes(value string) {
143		var v gobject.Value	143		var v gobject.Value
144		v.Init(gobject.TypeStringVal)	144		v.Init(gobject.TypeStringVal)
145	-	v.SetString(value)	145	+	v.SetString(&value)
146		x.SetProperty("attributes", &v)	146		x.SetProperty("attributes", &v)
147		}	147		}
148			148

@@ -159,7 +159,7 @@ func (x *BookmarkList) GetPropertyAttributes() string {
159		func (x *BookmarkList) SetPropertyFilename(value string) {	159		func (x *BookmarkList) SetPropertyFilename(value string) {
160		var v gobject.Value	160		var v gobject.Value
161		v.Init(gobject.TypeStringVal)	161		v.Init(gobject.TypeStringVal)
162	-	v.SetString(value)	162	+	v.SetString(&value)
163		x.SetProperty("filename", &v)	163		x.SetProperty("filename", &v)
164		}	164		}
165			165

M v4/gtk/gtkbuilder.go +4 -4


@@ -888,12 +888,12 @@ func (x *Builder) SetScope(ScopeVar BuilderScope) {
888			888
889		}	889		}
890			890
891	-	var xBuilderSetTranslationDomain func(uintptr, string)	891	+	var xBuilderSetTranslationDomain func(uintptr, uintptr)
892			892
893		// Sets the translation domain of @builder.	893		// Sets the translation domain of @builder.
894	-	func (x *Builder) SetTranslationDomain(DomainVar string) {	894	+	func (x Builder) SetTranslationDomain(DomainVar string) {
895			895
896	-	xBuilderSetTranslationDomain(x.GoPointer(), DomainVar)	896	+	xBuilderSetTranslationDomain(x.GoPointer(), core.NullableStringToPtr(DomainVar))
897			897
898		}	898		}
899			899

@@ -964,7 +964,7 @@ func (c *Builder) SetGoPointer(ptr uintptr) {
964		func (x *Builder) SetPropertyTranslationDomain(value string) {	964		func (x *Builder) SetPropertyTranslationDomain(value string) {
965		var v gobject.Value	965		var v gobject.Value
966		v.Init(gobject.TypeStringVal)	966		v.Init(gobject.TypeStringVal)
967	-	v.SetString(value)	967	+	v.SetString(&value)
968		x.SetProperty("translation-domain", &v)	968		x.SetProperty("translation-domain", &v)
969		}	969		}
970			970

M v4/gtk/gtkbuilderlistitemfactory.go +1 -1


@@ -172,7 +172,7 @@ func (x *BuilderListItemFactory) GetPropertyBytes() uintptr {
172		func (x *BuilderListItemFactory) SetPropertyResource(value string) {	172		func (x *BuilderListItemFactory) SetPropertyResource(value string) {
173		var v gobject.Value	173		var v gobject.Value
174		v.Init(gobject.TypeStringVal)	174		v.Init(gobject.TypeStringVal)
175	-	v.SetString(value)	175	+	v.SetString(&value)
176		x.SetProperty("resource", &v)	176		x.SetProperty("resource", &v)
177		}	177		}
178			178

M v4/gtk/gtkbuilderscope.go +32 -2


@@ -274,7 +274,22 @@ var xBuilderCScopeAddCallbackSymbol func(uintptr, string, uintptr)
274		// namespace.	274		// namespace.
275		func (x BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {	275		func (x BuilderCScope) AddCallbackSymbol(CallbackNameVar string, CallbackSymbolVar gobject.Callback) {
276			276
277	-	xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, glib.NewCallback(CallbackSymbolVar))	277	+	var CallbackSymbolVarRef uintptr
			278	+	if CallbackSymbolVar != nil {
			279	+	CallbackSymbolVarPtr := uintptr(unsafe.Pointer(CallbackSymbolVar))
			280	+	if cbRefPtr, ok := glib.GetCallback(CallbackSymbolVarPtr); ok {
			281	+	CallbackSymbolVarRef = cbRefPtr
			282	+	} else {
			283	+	fcb := func() {
			284	+	cbFn := *CallbackSymbolVar
			285	+	cbFn()
			286	+	}
			287	+	CallbackSymbolVarRef = purego.NewCallback(fcb)
			288	+	glib.SaveCallback(CallbackSymbolVarPtr, CallbackSymbolVarRef)
			289	+	}
			290	+	}
			291	+
			292	+	xBuilderCScopeAddCallbackSymbol(x.GoPointer(), CallbackNameVar, CallbackSymbolVarRef)
278			293
279		}	294		}
280			295

@@ -286,7 +301,22 @@ var xBuilderCScopeAddCallbackSymbols func(uintptr, string, uintptr, ...interface
286		// for each symbol.	301		// for each symbol.
287		func (x BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar gobject.Callback, varArgs ...interface{}) {	302		func (x BuilderCScope) AddCallbackSymbols(FirstCallbackNameVar string, FirstCallbackSymbolVar gobject.Callback, varArgs ...interface{}) {
288			303
289	-	xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, glib.NewCallback(FirstCallbackSymbolVar), varArgs...)	304	+	var FirstCallbackSymbolVarRef uintptr
			305	+	if FirstCallbackSymbolVar != nil {
			306	+	FirstCallbackSymbolVarPtr := uintptr(unsafe.Pointer(FirstCallbackSymbolVar))
			307	+	if cbRefPtr, ok := glib.GetCallback(FirstCallbackSymbolVarPtr); ok {
			308	+	FirstCallbackSymbolVarRef = cbRefPtr
			309	+	} else {
			310	+	fcb := func() {
			311	+	cbFn := *FirstCallbackSymbolVar
			312	+	cbFn()
			313	+	}
			314	+	FirstCallbackSymbolVarRef = purego.NewCallback(fcb)
			315	+	glib.SaveCallback(FirstCallbackSymbolVarPtr, FirstCallbackSymbolVarRef)
			316	+	}
			317	+	}
			318	+
			319	+	xBuilderCScopeAddCallbackSymbols(x.GoPointer(), FirstCallbackNameVar, FirstCallbackSymbolVarRef, varArgs...)
290			320
291		}	321		}
292			322

M v4/gtk/gtkbutton.go +4 -4


@@ -438,7 +438,7 @@ func (x *Button) GetPropertyHasFrame() bool {
438		func (x *Button) SetPropertyIconName(value string) {	438		func (x *Button) SetPropertyIconName(value string) {
439		var v gobject.Value	439		var v gobject.Value
440		v.Init(gobject.TypeStringVal)	440		v.Init(gobject.TypeStringVal)
441	-	v.SetString(value)	441	+	v.SetString(&value)
442		x.SetProperty("icon-name", &v)	442		x.SetProperty("icon-name", &v)
443		}	443		}
444			444

@@ -455,7 +455,7 @@ func (x *Button) GetPropertyIconName() string {
455		func (x *Button) SetPropertyLabel(value string) {	455		func (x *Button) SetPropertyLabel(value string) {
456		var v gobject.Value	456		var v gobject.Value
457		v.Init(gobject.TypeStringVal)	457		v.Init(gobject.TypeStringVal)
458	-	v.SetString(value)	458	+	v.SetString(&value)
459		x.SetProperty("label", &v)	459		x.SetProperty("label", &v)
460		}	460		}
461			461

@@ -827,9 +827,9 @@ func (x Button) GetActionTargetValue() glib.Variant {
827		// containing [class@ApplicationWindow] or its associated [class@Application],	827		// containing [class@ApplicationWindow] or its associated [class@Application],
828		// respectively. This is the same form used for actions in the [class@Gio.Menu]	828		// respectively. This is the same form used for actions in the [class@Gio.Menu]
829		// associated with the window.	829		// associated with the window.
830	-	func (x *Button) SetActionName(ActionNameVar string) {	830	+	func (x Button) SetActionName(ActionNameVar string) {
831			831
832	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	832	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
833			833
834		}	834		}
835			835

M v4/gtk/gtkcellarea.go +32 -2


@@ -1299,7 +1299,22 @@ var xCellAreaForeach func(uintptr, uintptr, uintptr)
1299		// Calls @callback for every `GtkCellRenderer` in @area.	1299		// Calls @callback for every `GtkCellRenderer` in @area.
1300		func (x CellArea) Foreach(CallbackVar CellCallback, CallbackDataVar uintptr) {	1300		func (x CellArea) Foreach(CallbackVar CellCallback, CallbackDataVar uintptr) {
1301			1301
1302	-	xCellAreaForeach(x.GoPointer(), glib.NewCallback(CallbackVar), CallbackDataVar)	1302	+	var CallbackVarRef uintptr
			1303	+	if CallbackVar != nil {
			1304	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1305	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1306	+	CallbackVarRef = cbRefPtr
			1307	+	} else {
			1308	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			1309	+	cbFn := *CallbackVar
			1310	+	return cbFn(arg0, arg1)
			1311	+	}
			1312	+	CallbackVarRef = purego.NewCallback(fcb)
			1313	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1314	+	}
			1315	+	}
			1316	+
			1317	+	xCellAreaForeach(x.GoPointer(), CallbackVarRef, CallbackDataVar)
1303			1318
1304		}	1319		}
1305			1320

@@ -1309,7 +1324,22 @@ var xCellAreaForeachAlloc func(uintptr, uintptr, uintptr, gdk.Rectangle, gdk.R
1309		// allocated rectangle inside @cell_area.	1324		// allocated rectangle inside @cell_area.
1310		func (x CellArea) ForeachAlloc(ContextVar CellAreaContext, WidgetVar Widget, CellAreaVar gdk.Rectangle, BackgroundAreaVar gdk.Rectangle, CallbackVar CellAllocCallback, CallbackDataVar uintptr) {	1325		func (x CellArea) ForeachAlloc(ContextVar CellAreaContext, WidgetVar Widget, CellAreaVar gdk.Rectangle, BackgroundAreaVar gdk.Rectangle, CallbackVar CellAllocCallback, CallbackDataVar uintptr) {
1311			1326
1312	-	xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, glib.NewCallback(CallbackVar), CallbackDataVar)	1327	+	var CallbackVarRef uintptr
			1328	+	if CallbackVar != nil {
			1329	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			1330	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			1331	+	CallbackVarRef = cbRefPtr
			1332	+	} else {
			1333	+	fcb := func(arg0 uintptr, arg1 gdk.Rectangle, arg2 gdk.Rectangle, arg3 uintptr) bool {
			1334	+	cbFn := *CallbackVar
			1335	+	return cbFn(arg0, arg1, arg2, arg3)
			1336	+	}
			1337	+	CallbackVarRef = purego.NewCallback(fcb)
			1338	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			1339	+	}
			1340	+	}
			1341	+
			1342	+	xCellAreaForeachAlloc(x.GoPointer(), ContextVar.GoPointer(), WidgetVar.GoPointer(), CellAreaVar, BackgroundAreaVar, CallbackVarRef, CallbackDataVar)
1313			1343
1314		}	1344		}
1315			1345

M v4/gtk/gtkcellrenderer.go +1 -1


@@ -743,7 +743,7 @@ func (c *CellRenderer) SetGoPointer(ptr uintptr) {
743		func (x *CellRenderer) SetPropertyCellBackground(value string) {	743		func (x *CellRenderer) SetPropertyCellBackground(value string) {
744		var v gobject.Value	744		var v gobject.Value
745		v.Init(gobject.TypeStringVal)	745		v.Init(gobject.TypeStringVal)
746	-	v.SetString(value)	746	+	v.SetString(&value)
747		x.SetProperty("cell-background", &v)	747		x.SetProperty("cell-background", &v)
748		}	748		}
749			749

M v4/gtk/gtkcellrendererpixbuf.go +1 -1


@@ -78,7 +78,7 @@ func (c *CellRendererPixbuf) SetGoPointer(ptr uintptr) {
78		func (x *CellRendererPixbuf) SetPropertyIconName(value string) {	78		func (x *CellRendererPixbuf) SetPropertyIconName(value string) {
79		var v gobject.Value	79		var v gobject.Value
80		v.Init(gobject.TypeStringVal)	80		v.Init(gobject.TypeStringVal)
81	-	v.SetString(value)	81	+	v.SetString(&value)
82		x.SetProperty("icon-name", &v)	82		x.SetProperty("icon-name", &v)
83		}	83		}
84			84

M v4/gtk/gtkcellrendererprogress.go +1 -1


@@ -116,7 +116,7 @@ func (x *CellRendererProgress) GetPropertyPulse() int {
116		func (x *CellRendererProgress) SetPropertyText(value string) {	116		func (x *CellRendererProgress) SetPropertyText(value string) {
117		var v gobject.Value	117		var v gobject.Value
118		v.Init(gobject.TypeStringVal)	118		v.Init(gobject.TypeStringVal)
119	-	v.SetString(value)	119	+	v.SetString(&value)
120		x.SetProperty("text", &v)	120		x.SetProperty("text", &v)
121		}	121		}
122			122

M v4/gtk/gtkcellrenderertext.go +8 -8


@@ -156,7 +156,7 @@ func (x *CellRendererText) GetPropertyAttributes() uintptr {
156		func (x *CellRendererText) SetPropertyBackground(value string) {	156		func (x *CellRendererText) SetPropertyBackground(value string) {
157		var v gobject.Value	157		var v gobject.Value
158		v.Init(gobject.TypeStringVal)	158		v.Init(gobject.TypeStringVal)
159	-	v.SetString(value)	159	+	v.SetString(&value)
160		x.SetProperty("background", &v)	160		x.SetProperty("background", &v)
161		}	161		}
162			162

@@ -241,7 +241,7 @@ func (x *CellRendererText) GetPropertyEllipsizeSet() bool {
241		func (x *CellRendererText) SetPropertyFamily(value string) {	241		func (x *CellRendererText) SetPropertyFamily(value string) {
242		var v gobject.Value	242		var v gobject.Value
243		v.Init(gobject.TypeStringVal)	243		v.Init(gobject.TypeStringVal)
244	-	v.SetString(value)	244	+	v.SetString(&value)
245		x.SetProperty("family", &v)	245		x.SetProperty("family", &v)
246		}	246		}
247			247

@@ -271,7 +271,7 @@ func (x *CellRendererText) GetPropertyFamilySet() bool {
271		func (x *CellRendererText) SetPropertyFont(value string) {	271		func (x *CellRendererText) SetPropertyFont(value string) {
272		var v gobject.Value	272		var v gobject.Value
273		v.Init(gobject.TypeStringVal)	273		v.Init(gobject.TypeStringVal)
274	-	v.SetString(value)	274	+	v.SetString(&value)
275		x.SetProperty("font", &v)	275		x.SetProperty("font", &v)
276		}	276		}
277			277

@@ -301,7 +301,7 @@ func (x *CellRendererText) GetPropertyFontDesc() uintptr {
301		func (x *CellRendererText) SetPropertyForeground(value string) {	301		func (x *CellRendererText) SetPropertyForeground(value string) {
302		var v gobject.Value	302		var v gobject.Value
303		v.Init(gobject.TypeStringVal)	303		v.Init(gobject.TypeStringVal)
304	-	v.SetString(value)	304	+	v.SetString(&value)
305		x.SetProperty("foreground", &v)	305		x.SetProperty("foreground", &v)
306		}	306		}
307			307

@@ -341,7 +341,7 @@ func (x *CellRendererText) GetPropertyForegroundSet() bool {
341		func (x *CellRendererText) SetPropertyLanguage(value string) {	341		func (x *CellRendererText) SetPropertyLanguage(value string) {
342		var v gobject.Value	342		var v gobject.Value
343		v.Init(gobject.TypeStringVal)	343		v.Init(gobject.TypeStringVal)
344	-	v.SetString(value)	344	+	v.SetString(&value)
345		x.SetProperty("language", &v)	345		x.SetProperty("language", &v)
346		}	346		}
347			347

@@ -371,7 +371,7 @@ func (x *CellRendererText) GetPropertyLanguageSet() bool {
371		func (x *CellRendererText) SetPropertyMarkup(value string) {	371		func (x *CellRendererText) SetPropertyMarkup(value string) {
372		var v gobject.Value	372		var v gobject.Value
373		v.Init(gobject.TypeStringVal)	373		v.Init(gobject.TypeStringVal)
374	-	v.SetString(value)	374	+	v.SetString(&value)
375		x.SetProperty("markup", &v)	375		x.SetProperty("markup", &v)
376		}	376		}
377			377

@@ -412,7 +412,7 @@ func (x *CellRendererText) GetPropertyMaxWidthChars() int {
412		func (x *CellRendererText) SetPropertyPlaceholderText(value string) {	412		func (x *CellRendererText) SetPropertyPlaceholderText(value string) {
413		var v gobject.Value	413		var v gobject.Value
414		v.Init(gobject.TypeStringVal)	414		v.Init(gobject.TypeStringVal)
415	-	v.SetString(value)	415	+	v.SetString(&value)
416		x.SetProperty("placeholder-text", &v)	416		x.SetProperty("placeholder-text", &v)
417		}	417		}
418			418

@@ -609,7 +609,7 @@ func (x *CellRendererText) GetPropertyStyleSet() bool {
609		func (x *CellRendererText) SetPropertyText(value string) {	609		func (x *CellRendererText) SetPropertyText(value string) {
610		var v gobject.Value	610		var v gobject.Value
611		v.Init(gobject.TypeStringVal)	611		v.Init(gobject.TypeStringVal)
612	-	v.SetString(value)	612	+	v.SetString(&value)
613		x.SetProperty("text", &v)	613		x.SetProperty("text", &v)
614		}	614		}
615			615

M v4/gtk/gtkcheckbutton.go +12 -12


@@ -180,13 +180,13 @@ func NewCheckButton() *CheckButton {
180		return cls	180		return cls
181		}	181		}
182			182
183	-	var xNewCheckButtonWithLabel func(string) uintptr	183	+	var xNewCheckButtonWithLabel func(uintptr) uintptr
184			184
185		// Creates a new `GtkCheckButton` with the given text.	185		// Creates a new `GtkCheckButton` with the given text.
186	-	func NewCheckButtonWithLabel(LabelVar string) *CheckButton {	186	+	func NewCheckButtonWithLabel(LabelVar string) CheckButton {
187		var cls *CheckButton	187		var cls *CheckButton
188			188
189	-	cret := xNewCheckButtonWithLabel(LabelVar)	189	+	cret := xNewCheckButtonWithLabel(core.NullableStringToPtr(LabelVar))
190			190
191		if cret == 0 {	191		if cret == 0 {
192		return nil	192		return nil

@@ -197,13 +197,13 @@ func NewCheckButtonWithLabel(LabelVar string) *CheckButton {
197		return cls	197		return cls
198		}	198		}
199			199
200	-	var xNewCheckButtonWithMnemonic func(string) uintptr	200	+	var xNewCheckButtonWithMnemonic func(uintptr) uintptr
201			201
202		// Creates a new `GtkCheckButton` with the given text and a mnemonic.	202		// Creates a new `GtkCheckButton` with the given text and a mnemonic.
203	-	func NewCheckButtonWithMnemonic(LabelVar string) *CheckButton {	203	+	func NewCheckButtonWithMnemonic(LabelVar string) CheckButton {
204		var cls *CheckButton	204		var cls *CheckButton
205			205
206	-	cret := xNewCheckButtonWithMnemonic(LabelVar)	206	+	cret := xNewCheckButtonWithMnemonic(core.NullableStringToPtr(LabelVar))
207			207
208		if cret == 0 {	208		if cret == 0 {
209		return nil	209		return nil

@@ -326,16 +326,16 @@ func (x *CheckButton) SetInconsistent(InconsistentVar bool) {
326			326
327		}	327		}
328			328
329	-	var xCheckButtonSetLabel func(uintptr, string)	329	+	var xCheckButtonSetLabel func(uintptr, uintptr)
330			330
331		// Sets the text of @self.	331		// Sets the text of @self.
332		//	332		//
333		// If [property@Gtk.CheckButton:use-underline] is %TRUE, an underscore	333		// If [property@Gtk.CheckButton:use-underline] is %TRUE, an underscore
334		// in @label is interpreted as mnemonic indicator, see	334		// in @label is interpreted as mnemonic indicator, see
335		// [method@Gtk.CheckButton.set_use_underline] for details on this behavior.	335		// [method@Gtk.CheckButton.set_use_underline] for details on this behavior.
336	-	func (x *CheckButton) SetLabel(LabelVar string) {	336	+	func (x CheckButton) SetLabel(LabelVar string) {
337			337
338	-	xCheckButtonSetLabel(x.GoPointer(), LabelVar)	338	+	xCheckButtonSetLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
339			339
340		}	340		}
341			341

@@ -414,7 +414,7 @@ func (x *CheckButton) GetPropertyInconsistent() bool {
414		func (x *CheckButton) SetPropertyLabel(value string) {	414		func (x *CheckButton) SetPropertyLabel(value string) {
415		var v gobject.Value	415		var v gobject.Value
416		v.Init(gobject.TypeStringVal)	416		v.Init(gobject.TypeStringVal)
417	-	v.SetString(value)	417	+	v.SetString(&value)
418		x.SetProperty("label", &v)	418		x.SetProperty("label", &v)
419		}	419		}
420			420

@@ -790,9 +790,9 @@ func (x CheckButton) GetActionTargetValue() glib.Variant {
790		// containing [class@ApplicationWindow] or its associated [class@Application],	790		// containing [class@ApplicationWindow] or its associated [class@Application],
791		// respectively. This is the same form used for actions in the [class@Gio.Menu]	791		// respectively. This is the same form used for actions in the [class@Gio.Menu]
792		// associated with the window.	792		// associated with the window.
793	-	func (x *CheckButton) SetActionName(ActionNameVar string) {	793	+	func (x CheckButton) SetActionName(ActionNameVar string) {
794			794
795	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	795	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
796			796
797		}	797		}
798			798

M v4/gtk/gtkcolorbutton.go +1 -1


@@ -187,7 +187,7 @@ func (x *ColorButton) GetPropertyShowEditor() bool {
187		func (x *ColorButton) SetPropertyTitle(value string) {	187		func (x *ColorButton) SetPropertyTitle(value string) {
188		var v gobject.Value	188		var v gobject.Value
189		v.Init(gobject.TypeStringVal)	189		v.Init(gobject.TypeStringVal)
190	-	v.SetString(value)	190	+	v.SetString(&value)
191		x.SetProperty("title", &v)	191		x.SetProperty("title", &v)
192		}	192		}
193			193

M v4/gtk/gtkcolorchooserdialog.go +3 -3


@@ -50,13 +50,13 @@ func ColorChooserDialogNewFromInternalPtr(ptr uintptr) *ColorChooserDialog {
50		return cls	50		return cls
51		}	51		}
52			52
53	-	var xNewColorChooserDialog func(string, uintptr) uintptr	53	+	var xNewColorChooserDialog func(uintptr, uintptr) uintptr
54			54
55		// Creates a new `GtkColorChooserDialog`.	55		// Creates a new `GtkColorChooserDialog`.
56	-	func NewColorChooserDialog(TitleVar string, ParentVar Window) ColorChooserDialog {	56	+	func NewColorChooserDialog(TitleVar string, ParentVar Window) *ColorChooserDialog {
57		var cls *ColorChooserDialog	57		var cls *ColorChooserDialog
58			58
59	-	cret := xNewColorChooserDialog(TitleVar, ParentVar.GoPointer())	59	+	cret := xNewColorChooserDialog(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer())
60			60
61		if cret == 0 {	61		if cret == 0 {
62		return nil	62		return nil

M v4/gtk/gtkcolordialog.go +17 -2


@@ -72,7 +72,22 @@ var xColorDialogChooseRgba func(uintptr, uintptr, *gdk.RGBA, uintptr, uintptr, u
72		// Presents a color chooser dialog to the user.	72		// Presents a color chooser dialog to the user.
73		func (x ColorDialog) ChooseRgba(ParentVar Window, InitialColorVar gdk.RGBA, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	73		func (x ColorDialog) ChooseRgba(ParentVar Window, InitialColorVar gdk.RGBA, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
74			74
75	-	xColorDialogChooseRgba(x.GoPointer(), ParentVar.GoPointer(), InitialColorVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	75	+	var CallbackVarRef uintptr
			76	+	if CallbackVar != nil {
			77	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			78	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			79	+	CallbackVarRef = cbRefPtr
			80	+	} else {
			81	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			82	+	cbFn := *CallbackVar
			83	+	cbFn(arg0, arg1, arg2)
			84	+	}
			85	+	CallbackVarRef = purego.NewCallback(fcb)
			86	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			87	+	}
			88	+	}
			89	+
			90	+	xColorDialogChooseRgba(x.GoPointer(), ParentVar.GoPointer(), InitialColorVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
76			91
77		}	92		}
78			93

@@ -186,7 +201,7 @@ func (x *ColorDialog) GetPropertyModal() bool {
186		func (x *ColorDialog) SetPropertyTitle(value string) {	201		func (x *ColorDialog) SetPropertyTitle(value string) {
187		var v gobject.Value	202		var v gobject.Value
188		v.Init(gobject.TypeStringVal)	203		v.Init(gobject.TypeStringVal)
189	-	v.SetString(value)	204	+	v.SetString(&value)
190		x.SetProperty("title", &v)	205		x.SetProperty("title", &v)
191		}	206		}
192			207

M v4/gtk/gtkcolumnviewcolumn.go +11 -11


@@ -48,7 +48,7 @@ func ColumnViewColumnNewFromInternalPtr(ptr uintptr) *ColumnViewColumn {
48		return cls	48		return cls
49		}	49		}
50			50
51	-	var xNewColumnViewColumn func(string, uintptr) uintptr	51	+	var xNewColumnViewColumn func(uintptr, uintptr) uintptr
52			52
53		// Creates a new `GtkColumnViewColumn` that uses the given @factory for	53		// Creates a new `GtkColumnViewColumn` that uses the given @factory for
54		// mapping items to widgets.	54		// mapping items to widgets.

@@ -63,10 +63,10 @@ var xNewColumnViewColumn func(string, uintptr) uintptr
63		// gtk_builder_list_item_factory_new_from_resource ("/name.ui"));	63		// gtk_builder_list_item_factory_new_from_resource ("/name.ui"));
64		//	64		//
65		// ```	65		// ```
66	-	func NewColumnViewColumn(TitleVar string, FactoryVar ListItemFactory) ColumnViewColumn {	66	+	func NewColumnViewColumn(TitleVar string, FactoryVar ListItemFactory) *ColumnViewColumn {
67		var cls *ColumnViewColumn	67		var cls *ColumnViewColumn
68			68
69	-	cret := xNewColumnViewColumn(TitleVar, FactoryVar.GoPointer())	69	+	cret := xNewColumnViewColumn(core.NullableStringToPtr(TitleVar), FactoryVar.GoPointer())
70			70
71		if cret == 0 {	71		if cret == 0 {
72		return nil	72		return nil

@@ -248,7 +248,7 @@ func (x ColumnViewColumn) SetHeaderMenu(MenuVar gio.MenuModel) {
248			248
249		}	249		}
250			250
251	-	var xColumnViewColumnSetId func(uintptr, string)	251	+	var xColumnViewColumnSetId func(uintptr, uintptr)
252			252
253		// Sets the id of this column.	253		// Sets the id of this column.
254		//	254		//

@@ -256,9 +256,9 @@ var xColumnViewColumnSetId func(uintptr, string)
256		// storing column view configuration.	256		// storing column view configuration.
257		//	257		//
258		// It is up to callers to ensure uniqueness of IDs.	258		// It is up to callers to ensure uniqueness of IDs.
259	-	func (x *ColumnViewColumn) SetId(IdVar string) {	259	+	func (x ColumnViewColumn) SetId(IdVar string) {
260			260
261	-	xColumnViewColumnSetId(x.GoPointer(), IdVar)	261	+	xColumnViewColumnSetId(x.GoPointer(), core.NullableStringToPtr(IdVar))
262			262
263		}	263		}
264			264

@@ -289,16 +289,16 @@ func (x ColumnViewColumn) SetSorter(SorterVar Sorter) {
289			289
290		}	290		}
291			291
292	-	var xColumnViewColumnSetTitle func(uintptr, string)	292	+	var xColumnViewColumnSetTitle func(uintptr, uintptr)
293			293
294		// Sets the title of this column.	294		// Sets the title of this column.
295		//	295		//
296		// The title is displayed in the header of a `GtkColumnView`	296		// The title is displayed in the header of a `GtkColumnView`
297		// for this column and is therefore user-facing text that should	297		// for this column and is therefore user-facing text that should
298		// be translated.	298		// be translated.
299	-	func (x *ColumnViewColumn) SetTitle(TitleVar string) {	299	+	func (x ColumnViewColumn) SetTitle(TitleVar string) {
300			300
301	-	xColumnViewColumnSetTitle(x.GoPointer(), TitleVar)	301	+	xColumnViewColumnSetTitle(x.GoPointer(), core.NullableStringToPtr(TitleVar))
302			302
303		}	303		}
304			304

@@ -369,7 +369,7 @@ func (x *ColumnViewColumn) GetPropertyFixedWidth() int {
369		func (x *ColumnViewColumn) SetPropertyId(value string) {	369		func (x *ColumnViewColumn) SetPropertyId(value string) {
370		var v gobject.Value	370		var v gobject.Value
371		v.Init(gobject.TypeStringVal)	371		v.Init(gobject.TypeStringVal)
372	-	v.SetString(value)	372	+	v.SetString(&value)
373		x.SetProperty("id", &v)	373		x.SetProperty("id", &v)
374		}	374		}
375			375

@@ -409,7 +409,7 @@ func (x *ColumnViewColumn) GetPropertyResizable() bool {
409		func (x *ColumnViewColumn) SetPropertyTitle(value string) {	409		func (x *ColumnViewColumn) SetPropertyTitle(value string) {
410		var v gobject.Value	410		var v gobject.Value
411		v.Init(gobject.TypeStringVal)	411		v.Init(gobject.TypeStringVal)
412	-	v.SetString(value)	412	+	v.SetString(&value)
413		x.SetProperty("title", &v)	413		x.SetProperty("title", &v)
414		}	414		}
415			415

M v4/gtk/gtkcolumnviewrow.go +2 -2


@@ -219,7 +219,7 @@ func (c *ColumnViewRow) SetGoPointer(ptr uintptr) {
219		func (x *ColumnViewRow) SetPropertyAccessibleDescription(value string) {	219		func (x *ColumnViewRow) SetPropertyAccessibleDescription(value string) {
220		var v gobject.Value	220		var v gobject.Value
221		v.Init(gobject.TypeStringVal)	221		v.Init(gobject.TypeStringVal)
222	-	v.SetString(value)	222	+	v.SetString(&value)
223		x.SetProperty("accessible-description", &v)	223		x.SetProperty("accessible-description", &v)
224		}	224		}
225			225

@@ -236,7 +236,7 @@ func (x *ColumnViewRow) GetPropertyAccessibleDescription() string {
236		func (x *ColumnViewRow) SetPropertyAccessibleLabel(value string) {	236		func (x *ColumnViewRow) SetPropertyAccessibleLabel(value string) {
237		var v gobject.Value	237		var v gobject.Value
238		v.Init(gobject.TypeStringVal)	238		v.Init(gobject.TypeStringVal)
239	-	v.SetString(value)	239	+	v.SetString(&value)
240		x.SetProperty("accessible-label", &v)	240		x.SetProperty("accessible-label", &v)
241		}	241		}
242			242

M v4/gtk/gtkcombobox.go +35 -5

 }
-var xComboBoxSetActiveId func(uintptr, string) bool
+var xComboBoxSetActiveId func(uintptr, uintptr) bool
 // Changes the active row of @combo_box to the one that has an ID equal to
 // @active_id.
 // If the [property@Gtk.ComboBox:id-column] property of @combo_box is
 // unset or if no row has the given ID then the function does nothing
 // and returns %FALSE.
-func (x *ComboBox) SetActiveId(ActiveIdVar string) bool {
+func (x *ComboBox) SetActiveId(ActiveIdVar *string) bool {
-	cret := xComboBoxSetActiveId(x.GoPointer(), ActiveIdVar)
+	cret := xComboBoxSetActiveId(x.GoPointer(), core.NullableStringToPtr(ActiveIdVar))
 	return cret
 }
 // This is the default value.
 func (x *ComboBox) SetRowSeparatorFunc(FuncVar *TreeViewRowSeparatorFunc, DataVar uintptr, DestroyVar *glib.DestroyNotify) {
-	xComboBoxSetRowSeparatorFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), DataVar, glib.NewCallbackNullable(DestroyVar))
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 *TreeIter, arg2 uintptr) bool {
+				cbFn := *FuncVar
+				return cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	var DestroyVarRef uintptr
+	if DestroyVar != nil {
+		DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
+		if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
+			DestroyVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr) {
+				cbFn := *DestroyVar
+				cbFn(arg0)
+			}
+			DestroyVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
+		}
+	}
+	xComboBoxSetRowSeparatorFunc(x.GoPointer(), FuncVarRef, DataVar, DestroyVarRef)
 }
 func (x *ComboBox) SetPropertyActiveId(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("active-id", &v)
 }

M v4/gtk/gtkcomboboxtext.go +9 -9


@@ -124,7 +124,7 @@ func NewComboBoxTextWithEntry() *ComboBoxText {
124		return cls	124		return cls
125		}	125		}
126			126
127	-	var xComboBoxTextAppend func(uintptr, string, string)	127	+	var xComboBoxTextAppend func(uintptr, uintptr, string)
128			128
129		// Appends @text to the list of strings stored in @combo_box.	129		// Appends @text to the list of strings stored in @combo_box.
130		//	130		//

@@ -132,9 +132,9 @@ var xComboBoxTextAppend func(uintptr, string, string)
132		//	132		//
133		// This is the same as calling [method@Gtk.ComboBoxText.insert]	133		// This is the same as calling [method@Gtk.ComboBoxText.insert]
134		// with a position of -1.	134		// with a position of -1.
135	-	func (x *ComboBoxText) Append(IdVar string, TextVar string) {	135	+	func (x ComboBoxText) Append(IdVar string, TextVar string) {
136			136
137	-	xComboBoxTextAppend(x.GoPointer(), IdVar, TextVar)	137	+	xComboBoxTextAppend(x.GoPointer(), core.NullableStringToPtr(IdVar), TextVar)
138			138
139		}	139		}
140			140

@@ -164,7 +164,7 @@ func (x *ComboBoxText) GetActiveText() string {
164		return cret	164		return cret
165		}	165		}
166			166
167	-	var xComboBoxTextInsert func(uintptr, int, string, string)	167	+	var xComboBoxTextInsert func(uintptr, int, uintptr, string)
168			168
169		// Inserts @text at @position in the list of strings stored in @combo_box.	169		// Inserts @text at @position in the list of strings stored in @combo_box.
170		//	170		//

@@ -172,9 +172,9 @@ var xComboBoxTextInsert func(uintptr, int, string, string)
172		// See [property@Gtk.ComboBox:id-column].	172		// See [property@Gtk.ComboBox:id-column].
173		//	173		//
174		// If @position is negative then @text is appended.	174		// If @position is negative then @text is appended.
175	-	func (x *ComboBoxText) Insert(PositionVar int, IdVar string, TextVar string) {	175	+	func (x ComboBoxText) Insert(PositionVar int, IdVar string, TextVar string) {
176			176
177	-	xComboBoxTextInsert(x.GoPointer(), PositionVar, IdVar, TextVar)	177	+	xComboBoxTextInsert(x.GoPointer(), PositionVar, core.NullableStringToPtr(IdVar), TextVar)
178			178
179		}	179		}
180			180

@@ -192,7 +192,7 @@ func (x *ComboBoxText) InsertText(PositionVar int, TextVar string) {
192			192
193		}	193		}
194			194
195	-	var xComboBoxTextPrepend func(uintptr, string, string)	195	+	var xComboBoxTextPrepend func(uintptr, uintptr, string)
196			196
197		// Prepends @text to the list of strings stored in @combo_box.	197		// Prepends @text to the list of strings stored in @combo_box.
198		//	198		//

@@ -200,9 +200,9 @@ var xComboBoxTextPrepend func(uintptr, string, string)
200		//	200		//
201		// This is the same as calling [method@Gtk.ComboBoxText.insert]	201		// This is the same as calling [method@Gtk.ComboBoxText.insert]
202		// with a position of 0.	202		// with a position of 0.
203	-	func (x *ComboBoxText) Prepend(IdVar string, TextVar string) {	203	+	func (x ComboBoxText) Prepend(IdVar string, TextVar string) {
204			204
205	-	xComboBoxTextPrepend(x.GoPointer(), IdVar, TextVar)	205	+	xComboBoxTextPrepend(x.GoPointer(), core.NullableStringToPtr(IdVar), TextVar)
206			206
207		}	207		}
208			208

M v4/gtk/gtkconstraintguide.go +4 -4


@@ -133,14 +133,14 @@ func (x *ConstraintGuide) SetMinSize(WidthVar int, HeightVar int) {
133			133
134		}	134		}
135			135
136	-	var xConstraintGuideSetName func(uintptr, string)	136	+	var xConstraintGuideSetName func(uintptr, uintptr)
137			137
138		// Sets a name for the given `GtkConstraintGuide`.	138		// Sets a name for the given `GtkConstraintGuide`.
139		//	139		//
140		// The name is useful for debugging purposes.	140		// The name is useful for debugging purposes.
141	-	func (x *ConstraintGuide) SetName(NameVar string) {	141	+	func (x ConstraintGuide) SetName(NameVar string) {
142			142
143	-	xConstraintGuideSetName(x.GoPointer(), NameVar)	143	+	xConstraintGuideSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
144			144
145		}	145		}
146			146

@@ -250,7 +250,7 @@ func (x *ConstraintGuide) GetPropertyMinWidth() int {
250		func (x *ConstraintGuide) SetPropertyName(value string) {	250		func (x *ConstraintGuide) SetPropertyName(value string) {
251		var v gobject.Value	251		var v gobject.Value
252		v.Init(gobject.TypeStringVal)	252		v.Init(gobject.TypeStringVal)
253	-	v.SetString(value)	253	+	v.SetString(&value)
254		x.SetProperty("name", &v)	254		x.SetProperty("name", &v)
255		}	255		}
256			256

M v4/gtk/gtkcssprovider.go +3 -3


@@ -156,16 +156,16 @@ func (x *CssProvider) LoadFromString(StringVar string) {
156			156
157		}	157		}
158			158
159	-	var xCssProviderLoadNamed func(uintptr, string, string)	159	+	var xCssProviderLoadNamed func(uintptr, string, uintptr)
160			160
161		// Loads a theme from the usual theme paths.	161		// Loads a theme from the usual theme paths.
162		//	162		//
163		// The actual process of finding the theme might change between	163		// The actual process of finding the theme might change between
164		// releases, but it is guaranteed that this function uses the same	164		// releases, but it is guaranteed that this function uses the same
165		// mechanism to load the theme that GTK uses for loading its own theme.	165		// mechanism to load the theme that GTK uses for loading its own theme.
166	-	func (x *CssProvider) LoadNamed(NameVar string, VariantVar string) {	166	+	func (x CssProvider) LoadNamed(NameVar string, VariantVar string) {
167			167
168	-	xCssProviderLoadNamed(x.GoPointer(), NameVar, VariantVar)	168	+	xCssProviderLoadNamed(x.GoPointer(), NameVar, core.NullableStringToPtr(VariantVar))
169			169
170		}	170		}
171			171

M v4/gtk/gtkcustomfilter.go +62 -2


@@ -55,7 +55,37 @@ var xNewCustomFilter func(uintptr, uintptr, uintptr) uintptr
55		func NewCustomFilter(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomFilter {	55		func NewCustomFilter(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomFilter {
56		var cls *CustomFilter	56		var cls *CustomFilter
57			57
58	-	cret := xNewCustomFilter(glib.NewCallbackNullable(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))	58	+	var MatchFuncVarRef uintptr
			59	+	if MatchFuncVar != nil {
			60	+	MatchFuncVarPtr := uintptr(unsafe.Pointer(MatchFuncVar))
			61	+	if cbRefPtr, ok := glib.GetCallback(MatchFuncVarPtr); ok {
			62	+	MatchFuncVarRef = cbRefPtr
			63	+	} else {
			64	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			65	+	cbFn := *MatchFuncVar
			66	+	return cbFn(arg0, arg1)
			67	+	}
			68	+	MatchFuncVarRef = purego.NewCallback(fcb)
			69	+	glib.SaveCallback(MatchFuncVarPtr, MatchFuncVarRef)
			70	+	}
			71	+	}
			72	+
			73	+	var UserDestroyVarRef uintptr
			74	+	if UserDestroyVar != nil {
			75	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			76	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			77	+	UserDestroyVarRef = cbRefPtr
			78	+	} else {
			79	+	fcb := func(arg0 uintptr) {
			80	+	cbFn := *UserDestroyVar
			81	+	cbFn(arg0)
			82	+	}
			83	+	UserDestroyVarRef = purego.NewCallback(fcb)
			84	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			85	+	}
			86	+	}
			87	+
			88	+	cret := xNewCustomFilter(MatchFuncVarRef, UserDataVar, UserDestroyVarRef)
59			89
60		if cret == 0 {	90		if cret == 0 {
61		return nil	91		return nil

@@ -78,7 +108,37 @@ var xCustomFilterSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
78		// will be called.	108		// will be called.
79		func (x CustomFilter) SetFilterFunc(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {	109		func (x CustomFilter) SetFilterFunc(MatchFuncVar CustomFilterFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
80			110
81	-	xCustomFilterSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(MatchFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))	111	+	var MatchFuncVarRef uintptr
			112	+	if MatchFuncVar != nil {
			113	+	MatchFuncVarPtr := uintptr(unsafe.Pointer(MatchFuncVar))
			114	+	if cbRefPtr, ok := glib.GetCallback(MatchFuncVarPtr); ok {
			115	+	MatchFuncVarRef = cbRefPtr
			116	+	} else {
			117	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			118	+	cbFn := *MatchFuncVar
			119	+	return cbFn(arg0, arg1)
			120	+	}
			121	+	MatchFuncVarRef = purego.NewCallback(fcb)
			122	+	glib.SaveCallback(MatchFuncVarPtr, MatchFuncVarRef)
			123	+	}
			124	+	}
			125	+
			126	+	var UserDestroyVarRef uintptr
			127	+	if UserDestroyVar != nil {
			128	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			129	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			130	+	UserDestroyVarRef = cbRefPtr
			131	+	} else {
			132	+	fcb := func(arg0 uintptr) {
			133	+	cbFn := *UserDestroyVar
			134	+	cbFn(arg0)
			135	+	}
			136	+	UserDestroyVarRef = purego.NewCallback(fcb)
			137	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			138	+	}
			139	+	}
			140	+
			141	+	xCustomFilterSetFilterFunc(x.GoPointer(), MatchFuncVarRef, UserDataVar, UserDestroyVarRef)
82			142
83		}	143		}
84			144

M v4/gtk/gtkcustomlayout.go +46 -1


@@ -62,7 +62,52 @@ var xNewCustomLayout func(uintptr, uintptr, uintptr) uintptr
62		func NewCustomLayout(RequestModeVar CustomRequestModeFunc, MeasureVar CustomMeasureFunc, AllocateVar CustomAllocateFunc) CustomLayout {	62		func NewCustomLayout(RequestModeVar CustomRequestModeFunc, MeasureVar CustomMeasureFunc, AllocateVar CustomAllocateFunc) CustomLayout {
63		var cls *CustomLayout	63		var cls *CustomLayout
64			64
65	-	cret := xNewCustomLayout(glib.NewCallbackNullable(RequestModeVar), glib.NewCallback(MeasureVar), glib.NewCallback(AllocateVar))	65	+	var RequestModeVarRef uintptr
			66	+	if RequestModeVar != nil {
			67	+	RequestModeVarPtr := uintptr(unsafe.Pointer(RequestModeVar))
			68	+	if cbRefPtr, ok := glib.GetCallback(RequestModeVarPtr); ok {
			69	+	RequestModeVarRef = cbRefPtr
			70	+	} else {
			71	+	fcb := func(arg0 uintptr) SizeRequestMode {
			72	+	cbFn := *RequestModeVar
			73	+	return cbFn(arg0)
			74	+	}
			75	+	RequestModeVarRef = purego.NewCallback(fcb)
			76	+	glib.SaveCallback(RequestModeVarPtr, RequestModeVarRef)
			77	+	}
			78	+	}
			79	+
			80	+	var MeasureVarRef uintptr
			81	+	if MeasureVar != nil {
			82	+	MeasureVarPtr := uintptr(unsafe.Pointer(MeasureVar))
			83	+	if cbRefPtr, ok := glib.GetCallback(MeasureVarPtr); ok {
			84	+	MeasureVarRef = cbRefPtr
			85	+	} else {
			86	+	fcb := func(arg0 uintptr, arg1 Orientation, arg2 int, arg3 int, arg4 int, arg5 int, arg6 int) {
			87	+	cbFn := *MeasureVar
			88	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5, arg6)
			89	+	}
			90	+	MeasureVarRef = purego.NewCallback(fcb)
			91	+	glib.SaveCallback(MeasureVarPtr, MeasureVarRef)
			92	+	}
			93	+	}
			94	+
			95	+	var AllocateVarRef uintptr
			96	+	if AllocateVar != nil {
			97	+	AllocateVarPtr := uintptr(unsafe.Pointer(AllocateVar))
			98	+	if cbRefPtr, ok := glib.GetCallback(AllocateVarPtr); ok {
			99	+	AllocateVarRef = cbRefPtr
			100	+	} else {
			101	+	fcb := func(arg0 uintptr, arg1 int, arg2 int, arg3 int) {
			102	+	cbFn := *AllocateVar
			103	+	cbFn(arg0, arg1, arg2, arg3)
			104	+	}
			105	+	AllocateVarRef = purego.NewCallback(fcb)
			106	+	glib.SaveCallback(AllocateVarPtr, AllocateVarRef)
			107	+	}
			108	+	}
			109	+
			110	+	cret := xNewCustomLayout(RequestModeVarRef, MeasureVarRef, AllocateVarRef)
66			111
67		if cret == 0 {	112		if cret == 0 {
68		return nil	113		return nil

M v4/gtk/gtkcustomsorter.go +62 -2


@@ -47,7 +47,37 @@ var xNewCustomSorter func(uintptr, uintptr, uintptr) uintptr
47		func NewCustomSorter(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomSorter {	47		func NewCustomSorter(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *CustomSorter {
48		var cls *CustomSorter	48		var cls *CustomSorter
49			49
50	-	cret := xNewCustomSorter(glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallbackNullable(UserDestroyVar))	50	+	var SortFuncVarRef uintptr
			51	+	if SortFuncVar != nil {
			52	+	SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
			53	+	if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
			54	+	SortFuncVarRef = cbRefPtr
			55	+	} else {
			56	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			57	+	cbFn := *SortFuncVar
			58	+	return cbFn(arg0, arg1, arg2)
			59	+	}
			60	+	SortFuncVarRef = purego.NewCallback(fcb)
			61	+	glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
			62	+	}
			63	+	}
			64	+
			65	+	var UserDestroyVarRef uintptr
			66	+	if UserDestroyVar != nil {
			67	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			68	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			69	+	UserDestroyVarRef = cbRefPtr
			70	+	} else {
			71	+	fcb := func(arg0 uintptr) {
			72	+	cbFn := *UserDestroyVar
			73	+	cbFn(arg0)
			74	+	}
			75	+	UserDestroyVarRef = purego.NewCallback(fcb)
			76	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			77	+	}
			78	+	}
			79	+
			80	+	cret := xNewCustomSorter(SortFuncVarRef, UserDataVar, UserDestroyVarRef)
51			81
52		if cret == 0 {	82		if cret == 0 {
53		return nil	83		return nil

@@ -70,7 +100,37 @@ var xCustomSorterSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
70		// called now.	100		// called now.
71		func (x CustomSorter) SetSortFunc(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {	101		func (x CustomSorter) SetSortFunc(SortFuncVar glib.CompareDataFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
72			102
73	-	xCustomSorterSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))	103	+	var SortFuncVarRef uintptr
			104	+	if SortFuncVar != nil {
			105	+	SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
			106	+	if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
			107	+	SortFuncVarRef = cbRefPtr
			108	+	} else {
			109	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			110	+	cbFn := *SortFuncVar
			111	+	return cbFn(arg0, arg1, arg2)
			112	+	}
			113	+	SortFuncVarRef = purego.NewCallback(fcb)
			114	+	glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
			115	+	}
			116	+	}
			117	+
			118	+	var UserDestroyVarRef uintptr
			119	+	if UserDestroyVar != nil {
			120	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			121	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			122	+	UserDestroyVarRef = cbRefPtr
			123	+	} else {
			124	+	fcb := func(arg0 uintptr) {
			125	+	cbFn := *UserDestroyVar
			126	+	cbFn(arg0)
			127	+	}
			128	+	UserDestroyVarRef = purego.NewCallback(fcb)
			129	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			130	+	}
			131	+	}
			132	+
			133	+	xCustomSorterSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, UserDestroyVarRef)
74			134
75		}	135		}
76			136

M v4/gtk/gtkdialog.go +3 -3


@@ -306,7 +306,7 @@ func NewDialog() *Dialog {
306		return cls	306		return cls
307		}	307		}
308			308
309	-	var xNewDialogWithButtons func(string, uintptr, DialogFlags, string, ...interface{}) uintptr	309	+	var xNewDialogWithButtons func(uintptr, uintptr, DialogFlags, uintptr, ...interface{}) uintptr
310			310
311		// Creates a new `GtkDialog` with the given title and transient parent.	311		// Creates a new `GtkDialog` with the given title and transient parent.
312		//	312		//

@@ -343,10 +343,10 @@ var xNewDialogWithButtons func(string, uintptr, DialogFlags, string, ...interfac
343		// NULL);	343		// NULL);
344		//	344		//
345		// ```	345		// ```
346	-	func NewDialogWithButtons(TitleVar string, ParentVar Window, FlagsVar DialogFlags, FirstButtonTextVar string, varArgs ...interface{}) Dialog {	346	+	func NewDialogWithButtons(TitleVar string, ParentVar Window, FlagsVar DialogFlags, FirstButtonTextVar string, varArgs ...interface{}) Dialog {
347		var cls *Dialog	347		var cls *Dialog
348			348
349	-	cret := xNewDialogWithButtons(TitleVar, ParentVar.GoPointer(), FlagsVar, FirstButtonTextVar, varArgs...)	349	+	cret := xNewDialogWithButtons(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer(), FlagsVar, core.NullableStringToPtr(FirstButtonTextVar), varArgs...)
350			350
351		if cret == 0 {	351		if cret == 0 {
352		return nil	352		return nil

M v4/gtk/gtkdirectorylist.go +7 -7


@@ -61,16 +61,16 @@ func DirectoryListNewFromInternalPtr(ptr uintptr) *DirectoryList {
61		return cls	61		return cls
62		}	62		}
63			63
64	-	var xNewDirectoryList func(string, uintptr) uintptr	64	+	var xNewDirectoryList func(uintptr, uintptr) uintptr
65			65
66		// Creates a new `GtkDirectoryList`.	66		// Creates a new `GtkDirectoryList`.
67		//	67		//
68		// The `GtkDirectoryList` is querying the given @file	68		// The `GtkDirectoryList` is querying the given @file
69		// with the given @attributes.	69		// with the given @attributes.
70	-	func NewDirectoryList(AttributesVar string, FileVar gio.File) *DirectoryList {	70	+	func NewDirectoryList(AttributesVar string, FileVar gio.File) DirectoryList {
71		var cls *DirectoryList	71		var cls *DirectoryList
72			72
73	-	cret := xNewDirectoryList(AttributesVar, FileVar.GoPointer())	73	+	cret := xNewDirectoryList(core.NullableStringToPtr(AttributesVar), FileVar.GoPointer())
74			74
75		if cret == 0 {	75		if cret == 0 {
76		return nil	76		return nil

@@ -155,15 +155,15 @@ func (x *DirectoryList) IsLoading() bool {
155		return cret	155		return cret
156		}	156		}
157			157
158	-	var xDirectoryListSetAttributes func(uintptr, string)	158	+	var xDirectoryListSetAttributes func(uintptr, uintptr)
159			159
160		// Sets the @attributes to be enumerated and starts the enumeration.	160		// Sets the @attributes to be enumerated and starts the enumeration.
161		//	161		//
162		// If @attributes is %NULL, the list of file infos will still be created, it will just	162		// If @attributes is %NULL, the list of file infos will still be created, it will just
163		// not contain any extra attributes.	163		// not contain any extra attributes.
164	-	func (x *DirectoryList) SetAttributes(AttributesVar string) {	164	+	func (x DirectoryList) SetAttributes(AttributesVar string) {
165			165
166	-	xDirectoryListSetAttributes(x.GoPointer(), AttributesVar)	166	+	xDirectoryListSetAttributes(x.GoPointer(), core.NullableStringToPtr(AttributesVar))
167			167
168		}	168		}
169			169

@@ -229,7 +229,7 @@ func (c *DirectoryList) SetGoPointer(ptr uintptr) {
229		func (x *DirectoryList) SetPropertyAttributes(value string) {	229		func (x *DirectoryList) SetPropertyAttributes(value string) {
230		var v gobject.Value	230		var v gobject.Value
231		v.Init(gobject.TypeStringVal)	231		v.Init(gobject.TypeStringVal)
232	-	v.SetString(value)	232	+	v.SetString(&value)
233		x.SetProperty("attributes", &v)	233		x.SetProperty("attributes", &v)
234		}	234		}
235			235

M v4/gtk/gtkdrawingarea.go +31 -1


@@ -244,7 +244,37 @@ var xDrawingAreaSetDrawFunc func(uintptr, uintptr, uintptr, uintptr)
244		// on the drawing area. This will cause a redraw and will call @draw_func again.	244		// on the drawing area. This will cause a redraw and will call @draw_func again.
245		func (x DrawingArea) SetDrawFunc(DrawFuncVar DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	245		func (x DrawingArea) SetDrawFunc(DrawFuncVar DrawingAreaDrawFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
246			246
247	-	xDrawingAreaSetDrawFunc(x.GoPointer(), glib.NewCallbackNullable(DrawFuncVar), UserDataVar, glib.NewCallback(DestroyVar))	247	+	var DrawFuncVarRef uintptr
			248	+	if DrawFuncVar != nil {
			249	+	DrawFuncVarPtr := uintptr(unsafe.Pointer(DrawFuncVar))
			250	+	if cbRefPtr, ok := glib.GetCallback(DrawFuncVarPtr); ok {
			251	+	DrawFuncVarRef = cbRefPtr
			252	+	} else {
			253	+	fcb := func(arg0 uintptr, arg1 *cairo.Context, arg2 int, arg3 int, arg4 uintptr) {
			254	+	cbFn := *DrawFuncVar
			255	+	cbFn(arg0, arg1, arg2, arg3, arg4)
			256	+	}
			257	+	DrawFuncVarRef = purego.NewCallback(fcb)
			258	+	glib.SaveCallback(DrawFuncVarPtr, DrawFuncVarRef)
			259	+	}
			260	+	}
			261	+
			262	+	var DestroyVarRef uintptr
			263	+	if DestroyVar != nil {
			264	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			265	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			266	+	DestroyVarRef = cbRefPtr
			267	+	} else {
			268	+	fcb := func(arg0 uintptr) {
			269	+	cbFn := *DestroyVar
			270	+	cbFn(arg0)
			271	+	}
			272	+	DestroyVarRef = purego.NewCallback(fcb)
			273	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			274	+	}
			275	+	}
			276	+
			277	+	xDrawingAreaSetDrawFunc(x.GoPointer(), DrawFuncVarRef, UserDataVar, DestroyVarRef)
248			278
249		}	279		}
250			280

M v4/gtk/gtkeditable.go +1 -1


@@ -822,7 +822,7 @@ func (x *EditableBase) SetPropertyText(value string) {
822		obj.Ptr = x.GoPointer()	822		obj.Ptr = x.GoPointer()
823		var v gobject.Value	823		var v gobject.Value
824		v.Init(gobject.TypeStringVal)	824		v.Init(gobject.TypeStringVal)
825	-	v.SetString(value)	825	+	v.SetString(&value)
826		obj.SetProperty("text", &v)	826		obj.SetProperty("text", &v)
827		}	827		}
828			828

M v4/gtk/gtkentry.go +22 -22


@@ -751,7 +751,7 @@ func (x *Entry) SetIconFromGicon(IconPosVar EntryIconPosition, IconVar gio.Icon)
751			751
752		}	752		}
753			753
754	-	var xEntrySetIconFromIconName func(uintptr, EntryIconPosition, string)	754	+	var xEntrySetIconFromIconName func(uintptr, EntryIconPosition, uintptr)
755			755
756		// Sets the icon shown in the entry at the specified position	756		// Sets the icon shown in the entry at the specified position
757		// from the current icon theme.	757		// from the current icon theme.

@@ -761,9 +761,9 @@ var xEntrySetIconFromIconName func(uintptr, EntryIconPosition, string)
761		//	761		//
762		// If @icon_name is %NULL, no icon will be shown in the	762		// If @icon_name is %NULL, no icon will be shown in the
763		// specified position.	763		// specified position.
764	-	func (x *Entry) SetIconFromIconName(IconPosVar EntryIconPosition, IconNameVar string) {	764	+	func (x Entry) SetIconFromIconName(IconPosVar EntryIconPosition, IconNameVar string) {
765			765
766	-	xEntrySetIconFromIconName(x.GoPointer(), IconPosVar, IconNameVar)	766	+	xEntrySetIconFromIconName(x.GoPointer(), IconPosVar, core.NullableStringToPtr(IconNameVar))
767			767
768		}	768		}
769			769

@@ -787,7 +787,7 @@ func (x *Entry) SetIconSensitive(IconPosVar EntryIconPosition, SensitiveVar bool
787			787
788		}	788		}
789			789
790	-	var xEntrySetIconTooltipMarkup func(uintptr, EntryIconPosition, string)	790	+	var xEntrySetIconTooltipMarkup func(uintptr, EntryIconPosition, uintptr)
791			791
792		// Sets @tooltip as the contents of the tooltip for the icon at	792		// Sets @tooltip as the contents of the tooltip for the icon at
793		// the specified position.	793		// the specified position.

@@ -798,13 +798,13 @@ var xEntrySetIconTooltipMarkup func(uintptr, EntryIconPosition, string)
798		//	798		//
799		// See also [method@Gtk.Widget.set_tooltip_markup] and	799		// See also [method@Gtk.Widget.set_tooltip_markup] and
800		// [method@Gtk.Entry.set_icon_tooltip_text].	800		// [method@Gtk.Entry.set_icon_tooltip_text].
801	-	func (x *Entry) SetIconTooltipMarkup(IconPosVar EntryIconPosition, TooltipVar string) {	801	+	func (x Entry) SetIconTooltipMarkup(IconPosVar EntryIconPosition, TooltipVar string) {
802			802
803	-	xEntrySetIconTooltipMarkup(x.GoPointer(), IconPosVar, TooltipVar)	803	+	xEntrySetIconTooltipMarkup(x.GoPointer(), IconPosVar, core.NullableStringToPtr(TooltipVar))
804			804
805		}	805		}
806			806
807	-	var xEntrySetIconTooltipText func(uintptr, EntryIconPosition, string)	807	+	var xEntrySetIconTooltipText func(uintptr, EntryIconPosition, uintptr)
808			808
809		// Sets @tooltip as the contents of the tooltip for the icon	809		// Sets @tooltip as the contents of the tooltip for the icon
810		// at the specified position.	810		// at the specified position.

@@ -823,9 +823,9 @@ var xEntrySetIconTooltipText func(uintptr, EntryIconPosition, string)
823		// [property@Gtk.Widget:has-tooltip] back to %TRUE, or	823		// [property@Gtk.Widget:has-tooltip] back to %TRUE, or
824		// setting at least one non-empty tooltip on any icon	824		// setting at least one non-empty tooltip on any icon
825		// achieves the same result.	825		// achieves the same result.
826	-	func (x *Entry) SetIconTooltipText(IconPosVar EntryIconPosition, TooltipVar string) {	826	+	func (x Entry) SetIconTooltipText(IconPosVar EntryIconPosition, TooltipVar string) {
827			827
828	-	xEntrySetIconTooltipText(x.GoPointer(), IconPosVar, TooltipVar)	828	+	xEntrySetIconTooltipText(x.GoPointer(), IconPosVar, core.NullableStringToPtr(TooltipVar))
829			829
830		}	830		}
831			831

@@ -905,15 +905,15 @@ func (x *Entry) SetOverwriteMode(OverwriteVar bool) {
905			905
906		}	906		}
907			907
908	-	var xEntrySetPlaceholderText func(uintptr, string)	908	+	var xEntrySetPlaceholderText func(uintptr, uintptr)
909			909
910		// Sets text to be displayed in @entry when it is empty.	910		// Sets text to be displayed in @entry when it is empty.
911		//	911		//
912		// This can be used to give a visual hint of the expected	912		// This can be used to give a visual hint of the expected
913		// contents of the `GtkEntry`.	913		// contents of the `GtkEntry`.
914	-	func (x *Entry) SetPlaceholderText(TextVar string) {	914	+	func (x Entry) SetPlaceholderText(TextVar string) {
915			915
916	-	xEntrySetPlaceholderText(x.GoPointer(), TextVar)	916	+	xEntrySetPlaceholderText(x.GoPointer(), core.NullableStringToPtr(TextVar))
917			917
918		}	918		}
919			919

@@ -1087,7 +1087,7 @@ func (x *Entry) GetPropertyHasFrame() bool {
1087		func (x *Entry) SetPropertyImModule(value string) {	1087		func (x *Entry) SetPropertyImModule(value string) {
1088		var v gobject.Value	1088		var v gobject.Value
1089		v.Init(gobject.TypeStringVal)	1089		v.Init(gobject.TypeStringVal)
1090	-	v.SetString(value)	1090	+	v.SetString(&value)
1091		x.SetProperty("im-module", &v)	1091		x.SetProperty("im-module", &v)
1092		}	1092		}
1093			1093

@@ -1172,7 +1172,7 @@ func (x *Entry) GetPropertyMaxLength() int {
1172		func (x *Entry) SetPropertyMenuEntryIconPrimaryText(value string) {	1172		func (x *Entry) SetPropertyMenuEntryIconPrimaryText(value string) {
1173		var v gobject.Value	1173		var v gobject.Value
1174		v.Init(gobject.TypeStringVal)	1174		v.Init(gobject.TypeStringVal)
1175	-	v.SetString(value)	1175	+	v.SetString(&value)
1176		x.SetProperty("menu-entry-icon-primary-text", &v)	1176		x.SetProperty("menu-entry-icon-primary-text", &v)
1177		}	1177		}
1178			1178

@@ -1211,7 +1211,7 @@ func (x *Entry) GetPropertyMenuEntryIconPrimaryText() string {
1211		func (x *Entry) SetPropertyMenuEntryIconSecondaryText(value string) {	1211		func (x *Entry) SetPropertyMenuEntryIconSecondaryText(value string) {
1212		var v gobject.Value	1212		var v gobject.Value
1213		v.Init(gobject.TypeStringVal)	1213		v.Init(gobject.TypeStringVal)
1214	-	v.SetString(value)	1214	+	v.SetString(&value)
1215		x.SetProperty("menu-entry-icon-secondary-text", &v)	1215		x.SetProperty("menu-entry-icon-secondary-text", &v)
1216		}	1216		}
1217			1217

@@ -1257,7 +1257,7 @@ func (x *Entry) GetPropertyOverwriteMode() bool {
1257		func (x *Entry) SetPropertyPlaceholderText(value string) {	1257		func (x *Entry) SetPropertyPlaceholderText(value string) {
1258		var v gobject.Value	1258		var v gobject.Value
1259		v.Init(gobject.TypeStringVal)	1259		v.Init(gobject.TypeStringVal)
1260	-	v.SetString(value)	1260	+	v.SetString(&value)
1261		x.SetProperty("placeholder-text", &v)	1261		x.SetProperty("placeholder-text", &v)
1262		}	1262		}
1263			1263

@@ -1306,7 +1306,7 @@ func (x *Entry) GetPropertyPrimaryIconActivatable() bool {
1306		func (x *Entry) SetPropertyPrimaryIconName(value string) {	1306		func (x *Entry) SetPropertyPrimaryIconName(value string) {
1307		var v gobject.Value	1307		var v gobject.Value
1308		v.Init(gobject.TypeStringVal)	1308		v.Init(gobject.TypeStringVal)
1309	-	v.SetString(value)	1309	+	v.SetString(&value)
1310		x.SetProperty("primary-icon-name", &v)	1310		x.SetProperty("primary-icon-name", &v)
1311		}	1311		}
1312			1312

@@ -1356,7 +1356,7 @@ func (x *Entry) GetPropertyPrimaryIconSensitive() bool {
1356		func (x *Entry) SetPropertyPrimaryIconTooltipMarkup(value string) {	1356		func (x *Entry) SetPropertyPrimaryIconTooltipMarkup(value string) {
1357		var v gobject.Value	1357		var v gobject.Value
1358		v.Init(gobject.TypeStringVal)	1358		v.Init(gobject.TypeStringVal)
1359	-	v.SetString(value)	1359	+	v.SetString(&value)
1360		x.SetProperty("primary-icon-tooltip-markup", &v)	1360		x.SetProperty("primary-icon-tooltip-markup", &v)
1361		}	1361		}
1362			1362

@@ -1377,7 +1377,7 @@ func (x *Entry) GetPropertyPrimaryIconTooltipMarkup() string {
1377		func (x *Entry) SetPropertyPrimaryIconTooltipText(value string) {	1377		func (x *Entry) SetPropertyPrimaryIconTooltipText(value string) {
1378		var v gobject.Value	1378		var v gobject.Value
1379		v.Init(gobject.TypeStringVal)	1379		v.Init(gobject.TypeStringVal)
1380	-	v.SetString(value)	1380	+	v.SetString(&value)
1381		x.SetProperty("primary-icon-tooltip-text", &v)	1381		x.SetProperty("primary-icon-tooltip-text", &v)
1382		}	1382		}
1383			1383

@@ -1475,7 +1475,7 @@ func (x *Entry) GetPropertySecondaryIconActivatable() bool {
1475		func (x *Entry) SetPropertySecondaryIconName(value string) {	1475		func (x *Entry) SetPropertySecondaryIconName(value string) {
1476		var v gobject.Value	1476		var v gobject.Value
1477		v.Init(gobject.TypeStringVal)	1477		v.Init(gobject.TypeStringVal)
1478	-	v.SetString(value)	1478	+	v.SetString(&value)
1479		x.SetProperty("secondary-icon-name", &v)	1479		x.SetProperty("secondary-icon-name", &v)
1480		}	1480		}
1481			1481

@@ -1525,7 +1525,7 @@ func (x *Entry) GetPropertySecondaryIconSensitive() bool {
1525		func (x *Entry) SetPropertySecondaryIconTooltipMarkup(value string) {	1525		func (x *Entry) SetPropertySecondaryIconTooltipMarkup(value string) {
1526		var v gobject.Value	1526		var v gobject.Value
1527		v.Init(gobject.TypeStringVal)	1527		v.Init(gobject.TypeStringVal)
1528	-	v.SetString(value)	1528	+	v.SetString(&value)
1529		x.SetProperty("secondary-icon-tooltip-markup", &v)	1529		x.SetProperty("secondary-icon-tooltip-markup", &v)
1530		}	1530		}
1531			1531

@@ -1546,7 +1546,7 @@ func (x *Entry) GetPropertySecondaryIconTooltipMarkup() string {
1546		func (x *Entry) SetPropertySecondaryIconTooltipText(value string) {	1546		func (x *Entry) SetPropertySecondaryIconTooltipText(value string) {
1547		var v gobject.Value	1547		var v gobject.Value
1548		v.Init(gobject.TypeStringVal)	1548		v.Init(gobject.TypeStringVal)
1549	-	v.SetString(value)	1549	+	v.SetString(&value)
1550		x.SetProperty("secondary-icon-tooltip-text", &v)	1550		x.SetProperty("secondary-icon-tooltip-text", &v)
1551		}	1551		}
1552			1552

M v4/gtk/gtkentrybuffer.go +4 -4


@@ -398,15 +398,15 @@ func EntryBufferNewFromInternalPtr(ptr uintptr) *EntryBuffer {
398		return cls	398		return cls
399		}	399		}
400			400
401	-	var xNewEntryBuffer func(string, int) uintptr	401	+	var xNewEntryBuffer func(uintptr, int) uintptr
402			402
403		// Create a new `GtkEntryBuffer` object.	403		// Create a new `GtkEntryBuffer` object.
404		//	404		//
405		// Optionally, specify initial text to set in the buffer.	405		// Optionally, specify initial text to set in the buffer.
406	-	func NewEntryBuffer(InitialCharsVar string, NInitialCharsVar int) *EntryBuffer {	406	+	func NewEntryBuffer(InitialCharsVar string, NInitialCharsVar int) EntryBuffer {
407		var cls *EntryBuffer	407		var cls *EntryBuffer
408			408
409	-	cret := xNewEntryBuffer(InitialCharsVar, NInitialCharsVar)	409	+	cret := xNewEntryBuffer(core.NullableStringToPtr(InitialCharsVar), NInitialCharsVar)
410			410
411		if cret == 0 {	411		if cret == 0 {
412		return nil	412		return nil

@@ -579,7 +579,7 @@ func (x *EntryBuffer) GetPropertyMaxLength() int {
579		func (x *EntryBuffer) SetPropertyText(value string) {	579		func (x *EntryBuffer) SetPropertyText(value string) {
580		var v gobject.Value	580		var v gobject.Value
581		v.Init(gobject.TypeStringVal)	581		v.Init(gobject.TypeStringVal)
582	-	v.SetString(value)	582	+	v.SetString(&value)
583		x.SetProperty("text", &v)	583		x.SetProperty("text", &v)
584		}	584		}
585			585

M v4/gtk/gtkentrycompletion.go +31 -1


@@ -285,7 +285,37 @@ var xEntryCompletionSetMatchFunc func(uintptr, uintptr, uintptr, uintptr)
285		// should not be in the completion list.	285		// should not be in the completion list.
286		func (x EntryCompletion) SetMatchFunc(FuncVar EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {	286		func (x EntryCompletion) SetMatchFunc(FuncVar EntryCompletionMatchFunc, FuncDataVar uintptr, FuncNotifyVar *glib.DestroyNotify) {
287			287
288	-	xEntryCompletionSetMatchFunc(x.GoPointer(), glib.NewCallback(FuncVar), FuncDataVar, glib.NewCallback(FuncNotifyVar))	288	+	var FuncVarRef uintptr
			289	+	if FuncVar != nil {
			290	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			291	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			292	+	FuncVarRef = cbRefPtr
			293	+	} else {
			294	+	fcb := func(arg0 uintptr, arg1 string, arg2 *TreeIter, arg3 uintptr) bool {
			295	+	cbFn := *FuncVar
			296	+	return cbFn(arg0, arg1, arg2, arg3)
			297	+	}
			298	+	FuncVarRef = purego.NewCallback(fcb)
			299	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			300	+	}
			301	+	}
			302	+
			303	+	var FuncNotifyVarRef uintptr
			304	+	if FuncNotifyVar != nil {
			305	+	FuncNotifyVarPtr := uintptr(unsafe.Pointer(FuncNotifyVar))
			306	+	if cbRefPtr, ok := glib.GetCallback(FuncNotifyVarPtr); ok {
			307	+	FuncNotifyVarRef = cbRefPtr
			308	+	} else {
			309	+	fcb := func(arg0 uintptr) {
			310	+	cbFn := *FuncNotifyVar
			311	+	cbFn(arg0)
			312	+	}
			313	+	FuncNotifyVarRef = purego.NewCallback(fcb)
			314	+	glib.SaveCallback(FuncNotifyVarPtr, FuncNotifyVarRef)
			315	+	}
			316	+	}
			317	+
			318	+	xEntryCompletionSetMatchFunc(x.GoPointer(), FuncVarRef, FuncDataVar, FuncNotifyVarRef)
289			319
290		}	320		}
291			321

M v4/gtk/gtkeventcontroller.go +7 -7


@@ -164,12 +164,12 @@ func (x *EventController) Reset() {
164			164
165		}	165		}
166			166
167	-	var xEventControllerSetName func(uintptr, string)	167	+	var xEventControllerSetName func(uintptr, uintptr)
168			168
169		// Sets a name on the controller that can be used for debugging.	169		// Sets a name on the controller that can be used for debugging.
170	-	func (x *EventController) SetName(NameVar string) {	170	+	func (x EventController) SetName(NameVar string) {
171			171
172	-	xEventControllerSetName(x.GoPointer(), NameVar)	172	+	xEventControllerSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
173			173
174		}	174		}
175			175

@@ -198,12 +198,12 @@ func (x *EventController) SetPropagationPhase(PhaseVar PropagationPhase) {
198			198
199		}	199		}
200			200
201	-	var xEventControllerSetStaticName func(uintptr, string)	201	+	var xEventControllerSetStaticName func(uintptr, uintptr)
202			202
203		// Sets a name on the controller that can be used for debugging.	203		// Sets a name on the controller that can be used for debugging.
204	-	func (x *EventController) SetStaticName(NameVar string) {	204	+	func (x EventController) SetStaticName(NameVar string) {
205			205
206	-	xEventControllerSetStaticName(x.GoPointer(), NameVar)	206	+	xEventControllerSetStaticName(x.GoPointer(), core.NullableStringToPtr(NameVar))
207			207
208		}	208		}
209			209

@@ -223,7 +223,7 @@ func (c *EventController) SetGoPointer(ptr uintptr) {
223		func (x *EventController) SetPropertyName(value string) {	223		func (x *EventController) SetPropertyName(value string) {
224		var v gobject.Value	224		var v gobject.Value
225		v.Init(gobject.TypeStringVal)	225		v.Init(gobject.TypeStringVal)
226	-	v.SetString(value)	226	+	v.SetString(&value)
227		x.SetProperty("name", &v)	227		x.SetProperty("name", &v)
228		}	228		}
229			229

M v4/gtk/gtkexpander.go +10 -10


@@ -126,13 +126,13 @@ func ExpanderNewFromInternalPtr(ptr uintptr) *Expander {
126		return cls	126		return cls
127		}	127		}
128			128
129	-	var xNewExpander func(string) uintptr	129	+	var xNewExpander func(uintptr) uintptr
130			130
131		// Creates a new expander using @label as the text of the label.	131		// Creates a new expander using @label as the text of the label.
132	-	func NewExpander(LabelVar string) *Expander {	132	+	func NewExpander(LabelVar string) Expander {
133		var cls *Expander	133		var cls *Expander
134			134
135	-	cret := xNewExpander(LabelVar)	135	+	cret := xNewExpander(core.NullableStringToPtr(LabelVar))
136			136
137		if cret == 0 {	137		if cret == 0 {
138		return nil	138		return nil

@@ -143,7 +143,7 @@ func NewExpander(LabelVar string) *Expander {
143		return cls	143		return cls
144		}	144		}
145			145
146	-	var xNewExpanderWithMnemonic func(string) uintptr	146	+	var xNewExpanderWithMnemonic func(uintptr) uintptr
147			147
148		// Creates a new expander using @label as the text of the label.	148		// Creates a new expander using @label as the text of the label.
149		//	149		//

@@ -153,10 +153,10 @@ var xNewExpanderWithMnemonic func(string) uintptr
153		// a keyboard accelerator called a mnemonic.	153		// a keyboard accelerator called a mnemonic.
154		//	154		//
155		// Pressing Alt and that key activates the button.	155		// Pressing Alt and that key activates the button.
156	-	func NewExpanderWithMnemonic(LabelVar string) *Expander {	156	+	func NewExpanderWithMnemonic(LabelVar string) Expander {
157		var cls *Expander	157		var cls *Expander
158			158
159	-	cret := xNewExpanderWithMnemonic(LabelVar)	159	+	cret := xNewExpanderWithMnemonic(core.NullableStringToPtr(LabelVar))
160			160
161		if cret == 0 {	161		if cret == 0 {
162		return nil	162		return nil

@@ -276,14 +276,14 @@ func (x *Expander) SetExpanded(ExpandedVar bool) {
276			276
277		}	277		}
278			278
279	-	var xExpanderSetLabel func(uintptr, string)	279	+	var xExpanderSetLabel func(uintptr, uintptr)
280			280
281		// Sets the text of the label of the expander to @label.	281		// Sets the text of the label of the expander to @label.
282		//	282		//
283		// This will also clear any previously set labels.	283		// This will also clear any previously set labels.
284	-	func (x *Expander) SetLabel(LabelVar string) {	284	+	func (x Expander) SetLabel(LabelVar string) {
285			285
286	-	xExpanderSetLabel(x.GoPointer(), LabelVar)	286	+	xExpanderSetLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
287			287
288		}	288		}
289			289

@@ -360,7 +360,7 @@ func (x *Expander) GetPropertyExpanded() bool {
360		func (x *Expander) SetPropertyLabel(value string) {	360		func (x *Expander) SetPropertyLabel(value string) {
361		var v gobject.Value	361		var v gobject.Value
362		v.Init(gobject.TypeStringVal)	362		v.Init(gobject.TypeStringVal)
363	-	v.SetString(value)	363	+	v.SetString(&value)
364		x.SetProperty("label", &v)	364		x.SetProperty("label", &v)
365		}	365		}
366			366

M v4/gtk/gtkexpression.go +77 -2


@@ -181,7 +181,52 @@ var xNewCClosureExpression func(types.GType, uintptr, uint, uintptr, uintptr, ui
181		func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar gobject.Callback, UserDataVar uintptr, UserDestroyVar gobject.ClosureNotify) CClosureExpression {	181		func NewCClosureExpression(ValueTypeVar types.GType, MarshalVar gobject.ClosureMarshal, NParamsVar uint, ParamsVar uintptr, CallbackFuncVar gobject.Callback, UserDataVar uintptr, UserDestroyVar gobject.ClosureNotify) CClosureExpression {
182		var cls *CClosureExpression	182		var cls *CClosureExpression
183			183
184	-	cret := xNewCClosureExpression(ValueTypeVar, glib.NewCallbackNullable(MarshalVar), NParamsVar, ParamsVar, glib.NewCallback(CallbackFuncVar), UserDataVar, glib.NewCallbackNullable(UserDestroyVar))	184	+	var MarshalVarRef uintptr
			185	+	if MarshalVar != nil {
			186	+	MarshalVarPtr := uintptr(unsafe.Pointer(MarshalVar))
			187	+	if cbRefPtr, ok := glib.GetCallback(MarshalVarPtr); ok {
			188	+	MarshalVarRef = cbRefPtr
			189	+	} else {
			190	+	fcb := func(arg0 gobject.Closure, arg1 gobject.Value, arg2 uint, arg3 []gobject.Value, arg4 uintptr, arg5 uintptr) {
			191	+	cbFn := *MarshalVar
			192	+	cbFn(arg0, arg1, arg2, arg3, arg4, arg5)
			193	+	}
			194	+	MarshalVarRef = purego.NewCallback(fcb)
			195	+	glib.SaveCallback(MarshalVarPtr, MarshalVarRef)
			196	+	}
			197	+	}
			198	+
			199	+	var CallbackFuncVarRef uintptr
			200	+	if CallbackFuncVar != nil {
			201	+	CallbackFuncVarPtr := uintptr(unsafe.Pointer(CallbackFuncVar))
			202	+	if cbRefPtr, ok := glib.GetCallback(CallbackFuncVarPtr); ok {
			203	+	CallbackFuncVarRef = cbRefPtr
			204	+	} else {
			205	+	fcb := func() {
			206	+	cbFn := *CallbackFuncVar
			207	+	cbFn()
			208	+	}
			209	+	CallbackFuncVarRef = purego.NewCallback(fcb)
			210	+	glib.SaveCallback(CallbackFuncVarPtr, CallbackFuncVarRef)
			211	+	}
			212	+	}
			213	+
			214	+	var UserDestroyVarRef uintptr
			215	+	if UserDestroyVar != nil {
			216	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			217	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			218	+	UserDestroyVarRef = cbRefPtr
			219	+	} else {
			220	+	fcb := func(arg0 uintptr, arg1 *gobject.Closure) {
			221	+	cbFn := *UserDestroyVar
			222	+	cbFn(arg0, arg1)
			223	+	}
			224	+	UserDestroyVarRef = purego.NewCallback(fcb)
			225	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			226	+	}
			227	+	}
			228	+
			229	+	cret := xNewCClosureExpression(ValueTypeVar, MarshalVarRef, NParamsVar, ParamsVar, CallbackFuncVarRef, UserDataVar, UserDestroyVarRef)
185			230
186		if cret == 0 {	231		if cret == 0 {
187		return nil	232		return nil

@@ -629,7 +674,37 @@ var xExpressionWatch func(uintptr, uintptr, uintptr, uintptr, uintptr) *Expressi
629		// the @notify will be invoked.	674		// the @notify will be invoked.
630		func (x Expression) Watch(ThisVar gobject.Object, NotifyVar ExpressionNotify, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *ExpressionWatch {	675		func (x Expression) Watch(ThisVar gobject.Object, NotifyVar ExpressionNotify, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *ExpressionWatch {
631			676
632	-	cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), glib.NewCallback(NotifyVar), UserDataVar, glib.NewCallback(UserDestroyVar))	677	+	var NotifyVarRef uintptr
			678	+	if NotifyVar != nil {
			679	+	NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
			680	+	if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
			681	+	NotifyVarRef = cbRefPtr
			682	+	} else {
			683	+	fcb := func(arg0 uintptr) {
			684	+	cbFn := *NotifyVar
			685	+	cbFn(arg0)
			686	+	}
			687	+	NotifyVarRef = purego.NewCallback(fcb)
			688	+	glib.SaveCallback(NotifyVarPtr, NotifyVarRef)
			689	+	}
			690	+	}
			691	+
			692	+	var UserDestroyVarRef uintptr
			693	+	if UserDestroyVar != nil {
			694	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			695	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			696	+	UserDestroyVarRef = cbRefPtr
			697	+	} else {
			698	+	fcb := func(arg0 uintptr) {
			699	+	cbFn := *UserDestroyVar
			700	+	cbFn(arg0)
			701	+	}
			702	+	UserDestroyVarRef = purego.NewCallback(fcb)
			703	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			704	+	}
			705	+	}
			706	+
			707	+	cret := xExpressionWatch(x.GoPointer(), ThisVar.GoPointer(), NotifyVarRef, UserDataVar, UserDestroyVarRef)
633		return cret	708		return cret
634		}	709		}
635			710

M v4/gtk/gtkfilechooserdialog.go +3 -3


@@ -208,15 +208,15 @@ func FileChooserDialogNewFromInternalPtr(ptr uintptr) *FileChooserDialog {
208		return cls	208		return cls
209		}	209		}
210			210
211	-	var xNewFileChooserDialog func(string, uintptr, FileChooserAction, string, ...interface{}) uintptr	211	+	var xNewFileChooserDialog func(uintptr, uintptr, FileChooserAction, uintptr, ...interface{}) uintptr
212			212
213		// Creates a new `GtkFileChooserDialog`.	213		// Creates a new `GtkFileChooserDialog`.
214		//	214		//
215		// This function is analogous to [ctor@Gtk.Dialog.new_with_buttons].	215		// This function is analogous to [ctor@Gtk.Dialog.new_with_buttons].
216	-	func NewFileChooserDialog(TitleVar string, ParentVar Window, ActionVar FileChooserAction, FirstButtonTextVar string, varArgs ...interface{}) FileChooserDialog {	216	+	func NewFileChooserDialog(TitleVar string, ParentVar Window, ActionVar FileChooserAction, FirstButtonTextVar string, varArgs ...interface{}) FileChooserDialog {
217		var cls *FileChooserDialog	217		var cls *FileChooserDialog
218			218
219	-	cret := xNewFileChooserDialog(TitleVar, ParentVar.GoPointer(), ActionVar, FirstButtonTextVar, varArgs...)	219	+	cret := xNewFileChooserDialog(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer(), ActionVar, core.NullableStringToPtr(FirstButtonTextVar), varArgs...)
220			220
221		if cret == 0 {	221		if cret == 0 {
222		return nil	222		return nil

M v4/gtk/gtkfilechoosernative.go +11 -11


@@ -191,13 +191,13 @@ func FileChooserNativeNewFromInternalPtr(ptr uintptr) *FileChooserNative {
191		return cls	191		return cls
192		}	192		}
193			193
194	-	var xNewFileChooserNative func(string, uintptr, FileChooserAction, string, string) uintptr	194	+	var xNewFileChooserNative func(uintptr, uintptr, FileChooserAction, uintptr, uintptr) uintptr
195			195
196		// Creates a new `GtkFileChooserNative`.	196		// Creates a new `GtkFileChooserNative`.
197	-	func NewFileChooserNative(TitleVar string, ParentVar Window, ActionVar FileChooserAction, AcceptLabelVar string, CancelLabelVar string) FileChooserNative {	197	+	func NewFileChooserNative(TitleVar string, ParentVar Window, ActionVar FileChooserAction, AcceptLabelVar string, CancelLabelVar string) *FileChooserNative {
198		var cls *FileChooserNative	198		var cls *FileChooserNative
199			199
200	-	cret := xNewFileChooserNative(TitleVar, ParentVar.GoPointer(), ActionVar, AcceptLabelVar, CancelLabelVar)	200	+	cret := xNewFileChooserNative(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer(), ActionVar, core.NullableStringToPtr(AcceptLabelVar), core.NullableStringToPtr(CancelLabelVar))
201			201
202		if cret == 0 {	202		if cret == 0 {
203		return nil	203		return nil

@@ -225,7 +225,7 @@ func (x *FileChooserNative) GetCancelLabel() string {
225		return cret	225		return cret
226		}	226		}
227			227
228	-	var xFileChooserNativeSetAcceptLabel func(uintptr, string)	228	+	var xFileChooserNativeSetAcceptLabel func(uintptr, uintptr)
229			229
230		// Sets the custom label text for the accept button.	230		// Sets the custom label text for the accept button.
231		//	231		//

@@ -235,13 +235,13 @@ var xFileChooserNativeSetAcceptLabel func(uintptr, string)
235		// a keyboard accelerator called a mnemonic.	235		// a keyboard accelerator called a mnemonic.
236		//	236		//
237		// Pressing Alt and that key should activate the button.	237		// Pressing Alt and that key should activate the button.
238	-	func (x *FileChooserNative) SetAcceptLabel(AcceptLabelVar string) {	238	+	func (x FileChooserNative) SetAcceptLabel(AcceptLabelVar string) {
239			239
240	-	xFileChooserNativeSetAcceptLabel(x.GoPointer(), AcceptLabelVar)	240	+	xFileChooserNativeSetAcceptLabel(x.GoPointer(), core.NullableStringToPtr(AcceptLabelVar))
241			241
242		}	242		}
243			243
244	-	var xFileChooserNativeSetCancelLabel func(uintptr, string)	244	+	var xFileChooserNativeSetCancelLabel func(uintptr, uintptr)
245			245
246		// Sets the custom label text for the cancel button.	246		// Sets the custom label text for the cancel button.
247		//	247		//

@@ -251,9 +251,9 @@ var xFileChooserNativeSetCancelLabel func(uintptr, string)
251		// a keyboard accelerator called a mnemonic.	251		// a keyboard accelerator called a mnemonic.
252		//	252		//
253		// Pressing Alt and that key should activate the button.	253		// Pressing Alt and that key should activate the button.
254	-	func (x *FileChooserNative) SetCancelLabel(CancelLabelVar string) {	254	+	func (x FileChooserNative) SetCancelLabel(CancelLabelVar string) {
255			255
256	-	xFileChooserNativeSetCancelLabel(x.GoPointer(), CancelLabelVar)	256	+	xFileChooserNativeSetCancelLabel(x.GoPointer(), core.NullableStringToPtr(CancelLabelVar))
257			257
258		}	258		}
259			259

@@ -274,7 +274,7 @@ func (c *FileChooserNative) SetGoPointer(ptr uintptr) {
274		func (x *FileChooserNative) SetPropertyAcceptLabel(value string) {	274		func (x *FileChooserNative) SetPropertyAcceptLabel(value string) {
275		var v gobject.Value	275		var v gobject.Value
276		v.Init(gobject.TypeStringVal)	276		v.Init(gobject.TypeStringVal)
277	-	v.SetString(value)	277	+	v.SetString(&value)
278		x.SetProperty("accept-label", &v)	278		x.SetProperty("accept-label", &v)
279		}	279		}
280			280

@@ -293,7 +293,7 @@ func (x *FileChooserNative) GetPropertyAcceptLabel() string {
293		func (x *FileChooserNative) SetPropertyCancelLabel(value string) {	293		func (x *FileChooserNative) SetPropertyCancelLabel(value string) {
294		var v gobject.Value	294		var v gobject.Value
295		v.Init(gobject.TypeStringVal)	295		v.Init(gobject.TypeStringVal)
296	-	v.SetString(value)	296	+	v.SetString(&value)
297		x.SetProperty("cancel-label", &v)	297		x.SetProperty("cancel-label", &v)
298		}	298		}
299			299

M v4/gtk/gtkfiledialog.go +137 -17


@@ -181,7 +181,22 @@ var xFileDialogOpen func(uintptr, uintptr, uintptr, uintptr, uintptr)
181		// The @callback will be called when the dialog is closed.	181		// The @callback will be called when the dialog is closed.
182		func (x FileDialog) Open(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	182		func (x FileDialog) Open(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
183			183
184	-	xFileDialogOpen(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	184	+	var CallbackVarRef uintptr
			185	+	if CallbackVar != nil {
			186	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			187	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			188	+	CallbackVarRef = cbRefPtr
			189	+	} else {
			190	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			191	+	cbFn := *CallbackVar
			192	+	cbFn(arg0, arg1, arg2)
			193	+	}
			194	+	CallbackVarRef = purego.NewCallback(fcb)
			195	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			196	+	}
			197	+	}
			198	+
			199	+	xFileDialogOpen(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
185			200
186		}	201		}
187			202

@@ -221,7 +236,22 @@ var xFileDialogOpenMultiple func(uintptr, uintptr, uintptr, uintptr, uintptr)
221		// The @callback will be called when the dialog is closed.	236		// The @callback will be called when the dialog is closed.
222		func (x FileDialog) OpenMultiple(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	237		func (x FileDialog) OpenMultiple(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
223			238
224	-	xFileDialogOpenMultiple(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	239	+	var CallbackVarRef uintptr
			240	+	if CallbackVar != nil {
			241	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			242	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			243	+	CallbackVarRef = cbRefPtr
			244	+	} else {
			245	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			246	+	cbFn := *CallbackVar
			247	+	cbFn(arg0, arg1, arg2)
			248	+	}
			249	+	CallbackVarRef = purego.NewCallback(fcb)
			250	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			251	+	}
			252	+	}
			253	+
			254	+	xFileDialogOpenMultiple(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
225			255
226		}	256		}
227			257

@@ -264,7 +294,22 @@ var xFileDialogOpenMultipleTextFiles func(uintptr, uintptr, uintptr, uintptr, ui
264		// The @callback will be called when the dialog is closed.	294		// The @callback will be called when the dialog is closed.
265		func (x FileDialog) OpenMultipleTextFiles(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	295		func (x FileDialog) OpenMultipleTextFiles(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
266			296
267	-	xFileDialogOpenMultipleTextFiles(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	297	+	var CallbackVarRef uintptr
			298	+	if CallbackVar != nil {
			299	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			300	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			301	+	CallbackVarRef = cbRefPtr
			302	+	} else {
			303	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			304	+	cbFn := *CallbackVar
			305	+	cbFn(arg0, arg1, arg2)
			306	+	}
			307	+	CallbackVarRef = purego.NewCallback(fcb)
			308	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			309	+	}
			310	+	}
			311	+
			312	+	xFileDialogOpenMultipleTextFiles(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
268			313
269		}	314		}
270			315

@@ -303,7 +348,22 @@ var xFileDialogOpenTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
303		// The @callback will be called when the dialog is closed.	348		// The @callback will be called when the dialog is closed.
304		func (x FileDialog) OpenTextFile(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	349		func (x FileDialog) OpenTextFile(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
305			350
306	-	xFileDialogOpenTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	351	+	var CallbackVarRef uintptr
			352	+	if CallbackVar != nil {
			353	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			354	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			355	+	CallbackVarRef = cbRefPtr
			356	+	} else {
			357	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			358	+	cbFn := *CallbackVar
			359	+	cbFn(arg0, arg1, arg2)
			360	+	}
			361	+	CallbackVarRef = purego.NewCallback(fcb)
			362	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			363	+	}
			364	+	}
			365	+
			366	+	xFileDialogOpenTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
307			367
308		}	368		}
309			369

@@ -346,7 +406,22 @@ var xFileDialogSave func(uintptr, uintptr, uintptr, uintptr, uintptr)
346		// The @callback will be called when the dialog is closed.	406		// The @callback will be called when the dialog is closed.
347		func (x FileDialog) Save(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	407		func (x FileDialog) Save(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
348			408
349	-	xFileDialogSave(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	409	+	var CallbackVarRef uintptr
			410	+	if CallbackVar != nil {
			411	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			412	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			413	+	CallbackVarRef = cbRefPtr
			414	+	} else {
			415	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			416	+	cbFn := *CallbackVar
			417	+	cbFn(arg0, arg1, arg2)
			418	+	}
			419	+	CallbackVarRef = purego.NewCallback(fcb)
			420	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			421	+	}
			422	+	}
			423	+
			424	+	xFileDialogSave(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
350			425
351		}	426		}
352			427

@@ -386,7 +461,22 @@ var xFileDialogSaveTextFile func(uintptr, uintptr, uintptr, uintptr, uintptr)
386		// The @callback will be called when the dialog is closed.	461		// The @callback will be called when the dialog is closed.
387		func (x FileDialog) SaveTextFile(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	462		func (x FileDialog) SaveTextFile(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
388			463
389	-	xFileDialogSaveTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	464	+	var CallbackVarRef uintptr
			465	+	if CallbackVar != nil {
			466	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			467	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			468	+	CallbackVarRef = cbRefPtr
			469	+	} else {
			470	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			471	+	cbFn := *CallbackVar
			472	+	cbFn(arg0, arg1, arg2)
			473	+	}
			474	+	CallbackVarRef = purego.NewCallback(fcb)
			475	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			476	+	}
			477	+	}
			478	+
			479	+	xFileDialogSaveTextFile(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
390			480
391		}	481		}
392			482

@@ -436,7 +526,22 @@ var xFileDialogSelectFolder func(uintptr, uintptr, uintptr, uintptr, uintptr)
436		// The @callback will be called when the dialog is closed.	526		// The @callback will be called when the dialog is closed.
437		func (x FileDialog) SelectFolder(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	527		func (x FileDialog) SelectFolder(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
438			528
439	-	xFileDialogSelectFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	529	+	var CallbackVarRef uintptr
			530	+	if CallbackVar != nil {
			531	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			532	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			533	+	CallbackVarRef = cbRefPtr
			534	+	} else {
			535	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			536	+	cbFn := *CallbackVar
			537	+	cbFn(arg0, arg1, arg2)
			538	+	}
			539	+	CallbackVarRef = purego.NewCallback(fcb)
			540	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			541	+	}
			542	+	}
			543	+
			544	+	xFileDialogSelectFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
440			545
441		}	546		}
442			547

@@ -477,7 +582,22 @@ var xFileDialogSelectMultipleFolders func(uintptr, uintptr, uintptr, uintptr, ui
477		// The @callback will be called when the dialog is closed.	582		// The @callback will be called when the dialog is closed.
478		func (x FileDialog) SelectMultipleFolders(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	583		func (x FileDialog) SelectMultipleFolders(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
479			584
480	-	xFileDialogSelectMultipleFolders(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	585	+	var CallbackVarRef uintptr
			586	+	if CallbackVar != nil {
			587	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			588	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			589	+	CallbackVarRef = cbRefPtr
			590	+	} else {
			591	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			592	+	cbFn := *CallbackVar
			593	+	cbFn(arg0, arg1, arg2)
			594	+	}
			595	+	CallbackVarRef = purego.NewCallback(fcb)
			596	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			597	+	}
			598	+	}
			599	+
			600	+	xFileDialogSelectMultipleFolders(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
481			601
482		}	602		}
483			603

@@ -505,16 +625,16 @@ func (x FileDialog) SelectMultipleFoldersFinish(ResultVar gio.AsyncResult) (gi
505			625
506		}	626		}
507			627
508	-	var xFileDialogSetAcceptLabel func(uintptr, string)	628	+	var xFileDialogSetAcceptLabel func(uintptr, uintptr)
509			629
510		// Sets the label shown on the file chooser's accept button.	630		// Sets the label shown on the file chooser's accept button.
511		//	631		//
512		// Leaving the accept label unset or setting it as `NULL` will	632		// Leaving the accept label unset or setting it as `NULL` will
513		// fall back to a default label, depending on what API is used	633		// fall back to a default label, depending on what API is used
514		// to launch the file dialog.	634		// to launch the file dialog.
515	-	func (x *FileDialog) SetAcceptLabel(AcceptLabelVar string) {	635	+	func (x FileDialog) SetAcceptLabel(AcceptLabelVar string) {
516			636
517	-	xFileDialogSetAcceptLabel(x.GoPointer(), AcceptLabelVar)	637	+	xFileDialogSetAcceptLabel(x.GoPointer(), core.NullableStringToPtr(AcceptLabelVar))
518			638
519		}	639		}
520			640

@@ -567,7 +687,7 @@ func (x *FileDialog) SetInitialFolder(FolderVar gio.File) {
567			687
568		}	688		}
569			689
570	-	var xFileDialogSetInitialName func(uintptr, string)	690	+	var xFileDialogSetInitialName func(uintptr, uintptr)
571			691
572		// Sets the filename that will be initially selected.	692		// Sets the filename that will be initially selected.
573		//	693		//

@@ -577,9 +697,9 @@ var xFileDialogSetInitialName func(uintptr, string)
577		// If a file with this name already exists in the directory set	697		// If a file with this name already exists in the directory set
578		// via [property@Gtk.FileDialog:initial-folder], the dialog will	698		// via [property@Gtk.FileDialog:initial-folder], the dialog will
579		// preselect it.	699		// preselect it.
580	-	func (x *FileDialog) SetInitialName(NameVar string) {	700	+	func (x FileDialog) SetInitialName(NameVar string) {
581			701
582	-	xFileDialogSetInitialName(x.GoPointer(), NameVar)	702	+	xFileDialogSetInitialName(x.GoPointer(), core.NullableStringToPtr(NameVar))
583			703
584		}	704		}
585			705

@@ -618,7 +738,7 @@ func (c *FileDialog) SetGoPointer(ptr uintptr) {
618		func (x *FileDialog) SetPropertyAcceptLabel(value string) {	738		func (x *FileDialog) SetPropertyAcceptLabel(value string) {
619		var v gobject.Value	739		var v gobject.Value
620		v.Init(gobject.TypeStringVal)	740		v.Init(gobject.TypeStringVal)
621	-	v.SetString(value)	741	+	v.SetString(&value)
622		x.SetProperty("accept-label", &v)	742		x.SetProperty("accept-label", &v)
623		}	743		}
624			744

@@ -637,7 +757,7 @@ func (x *FileDialog) GetPropertyAcceptLabel() string {
637		func (x *FileDialog) SetPropertyInitialName(value string) {	757		func (x *FileDialog) SetPropertyInitialName(value string) {
638		var v gobject.Value	758		var v gobject.Value
639		v.Init(gobject.TypeStringVal)	759		v.Init(gobject.TypeStringVal)
640	-	v.SetString(value)	760	+	v.SetString(&value)
641		x.SetProperty("initial-name", &v)	761		x.SetProperty("initial-name", &v)
642		}	762		}
643			763

@@ -673,7 +793,7 @@ func (x *FileDialog) GetPropertyModal() bool {
673		func (x *FileDialog) SetPropertyTitle(value string) {	793		func (x *FileDialog) SetPropertyTitle(value string) {
674		var v gobject.Value	794		var v gobject.Value
675		v.Init(gobject.TypeStringVal)	795		v.Init(gobject.TypeStringVal)
676	-	v.SetString(value)	796	+	v.SetString(&value)
677		x.SetProperty("title", &v)	797		x.SetProperty("title", &v)
678		}	798		}
679			799

M v4/gtk/gtkfilefilter.go +4 -4


@@ -202,15 +202,15 @@ func (x *FileFilter) GetName() string {
202		return cret	202		return cret
203		}	203		}
204			204
205	-	var xFileFilterSetName func(uintptr, string)	205	+	var xFileFilterSetName func(uintptr, uintptr)
206			206
207		// Sets a human-readable name of the filter.	207		// Sets a human-readable name of the filter.
208		//	208		//
209		// This is the string that will be displayed in the user interface	209		// This is the string that will be displayed in the user interface
210		// if there is a selectable list of filters.	210		// if there is a selectable list of filters.
211	-	func (x *FileFilter) SetName(NameVar string) {	211	+	func (x FileFilter) SetName(NameVar string) {
212			212
213	-	xFileFilterSetName(x.GoPointer(), NameVar)	213	+	xFileFilterSetName(x.GoPointer(), core.NullableStringToPtr(NameVar))
214			214
215		}	215		}
216			216

@@ -251,7 +251,7 @@ func (x *FileFilter) SetPropertyMimeTypes(value []string) {
251		func (x *FileFilter) SetPropertyName(value string) {	251		func (x *FileFilter) SetPropertyName(value string) {
252		var v gobject.Value	252		var v gobject.Value
253		v.Init(gobject.TypeStringVal)	253		v.Init(gobject.TypeStringVal)
254	-	v.SetString(value)	254	+	v.SetString(&value)
255		x.SetProperty("name", &v)	255		x.SetProperty("name", &v)
256		}	256		}
257			257

M v4/gtk/gtkfilelauncher.go +32 -2


@@ -108,7 +108,22 @@ var xFileLauncherLaunch func(uintptr, uintptr, uintptr, uintptr, uintptr)
108		// This may present an app chooser dialog to the user.	108		// This may present an app chooser dialog to the user.
109		func (x FileLauncher) Launch(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	109		func (x FileLauncher) Launch(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
110			110
111	-	xFileLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	111	+	var CallbackVarRef uintptr
			112	+	if CallbackVar != nil {
			113	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			114	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			115	+	CallbackVarRef = cbRefPtr
			116	+	} else {
			117	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			118	+	cbFn := *CallbackVar
			119	+	cbFn(arg0, arg1, arg2)
			120	+	}
			121	+	CallbackVarRef = purego.NewCallback(fcb)
			122	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			123	+	}
			124	+	}
			125	+
			126	+	xFileLauncherLaunch(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
112			127
113		}	128		}
114			129

@@ -135,7 +150,22 @@ var xFileLauncherOpenContainingFolder func(uintptr, uintptr, uintptr, uintptr, u
135		// is e.g. a http:// uri.	150		// is e.g. a http:// uri.
136		func (x FileLauncher) OpenContainingFolder(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	151		func (x FileLauncher) OpenContainingFolder(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
137			152
138	-	xFileLauncherOpenContainingFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	153	+	var CallbackVarRef uintptr
			154	+	if CallbackVar != nil {
			155	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			156	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			157	+	CallbackVarRef = cbRefPtr
			158	+	} else {
			159	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			160	+	cbFn := *CallbackVar
			161	+	cbFn(arg0, arg1, arg2)
			162	+	}
			163	+	CallbackVarRef = purego.NewCallback(fcb)
			164	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			165	+	}
			166	+	}
			167	+
			168	+	xFileLauncherOpenContainingFolder(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
139			169
140		}	170		}
141			171

M v4/gtk/gtkflowbox.go +109 -4


@@ -198,7 +198,37 @@ var xFlowBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
198		// should be implemented by the model.	198		// should be implemented by the model.
199		func (x FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {	199		func (x FlowBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar FlowBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
200			200
201	-	xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallback(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))	201	+	var CreateWidgetFuncVarRef uintptr
			202	+	if CreateWidgetFuncVar != nil {
			203	+	CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
			204	+	if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
			205	+	CreateWidgetFuncVarRef = cbRefPtr
			206	+	} else {
			207	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			208	+	cbFn := *CreateWidgetFuncVar
			209	+	return cbFn(arg0, arg1)
			210	+	}
			211	+	CreateWidgetFuncVarRef = purego.NewCallback(fcb)
			212	+	glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
			213	+	}
			214	+	}
			215	+
			216	+	var UserDataFreeFuncVarRef uintptr
			217	+	if UserDataFreeFuncVar != nil {
			218	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			219	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			220	+	UserDataFreeFuncVarRef = cbRefPtr
			221	+	} else {
			222	+	fcb := func(arg0 uintptr) {
			223	+	cbFn := *UserDataFreeFuncVar
			224	+	cbFn(arg0)
			225	+	}
			226	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			227	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			228	+	}
			229	+	}
			230	+
			231	+	xFlowBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
202			232
203		}	233		}
204			234

@@ -414,7 +444,22 @@ var xFlowBoxSelectedForeach func(uintptr, uintptr, uintptr)
414		// this function.	444		// this function.
415		func (x FlowBox) SelectedForeach(FuncVar FlowBoxForeachFunc, DataVar uintptr) {	445		func (x FlowBox) SelectedForeach(FuncVar FlowBoxForeachFunc, DataVar uintptr) {
416			446
417	-	xFlowBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)	447	+	var FuncVarRef uintptr
			448	+	if FuncVar != nil {
			449	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			450	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			451	+	FuncVarRef = cbRefPtr
			452	+	} else {
			453	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			454	+	cbFn := *FuncVar
			455	+	cbFn(arg0, arg1, arg2)
			456	+	}
			457	+	FuncVarRef = purego.NewCallback(fcb)
			458	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			459	+	}
			460	+	}
			461	+
			462	+	xFlowBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
418			463
419		}	464		}
420			465

@@ -454,7 +499,37 @@ var xFlowBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
454		// (see [method@Gtk.FlowBox.bind_model]).	499		// (see [method@Gtk.FlowBox.bind_model]).
455		func (x FlowBox) SetFilterFunc(FilterFuncVar FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	500		func (x FlowBox) SetFilterFunc(FilterFuncVar FlowBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
456			501
457	-	xFlowBoxSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))	502	+	var FilterFuncVarRef uintptr
			503	+	if FilterFuncVar != nil {
			504	+	FilterFuncVarPtr := uintptr(unsafe.Pointer(FilterFuncVar))
			505	+	if cbRefPtr, ok := glib.GetCallback(FilterFuncVarPtr); ok {
			506	+	FilterFuncVarRef = cbRefPtr
			507	+	} else {
			508	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			509	+	cbFn := *FilterFuncVar
			510	+	return cbFn(arg0, arg1)
			511	+	}
			512	+	FilterFuncVarRef = purego.NewCallback(fcb)
			513	+	glib.SaveCallback(FilterFuncVarPtr, FilterFuncVarRef)
			514	+	}
			515	+	}
			516	+
			517	+	var DestroyVarRef uintptr
			518	+	if DestroyVar != nil {
			519	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			520	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			521	+	DestroyVarRef = cbRefPtr
			522	+	} else {
			523	+	fcb := func(arg0 uintptr) {
			524	+	cbFn := *DestroyVar
			525	+	cbFn(arg0)
			526	+	}
			527	+	DestroyVarRef = purego.NewCallback(fcb)
			528	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			529	+	}
			530	+	}
			531	+
			532	+	xFlowBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
458			533
459		}	534		}
460			535

@@ -544,7 +619,37 @@ var xFlowBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
544		// (see [method@Gtk.FlowBox.bind_model]).	619		// (see [method@Gtk.FlowBox.bind_model]).
545		func (x FlowBox) SetSortFunc(SortFuncVar FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	620		func (x FlowBox) SetSortFunc(SortFuncVar FlowBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
546			621
547	-	xFlowBoxSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))	622	+	var SortFuncVarRef uintptr
			623	+	if SortFuncVar != nil {
			624	+	SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
			625	+	if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
			626	+	SortFuncVarRef = cbRefPtr
			627	+	} else {
			628	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			629	+	cbFn := *SortFuncVar
			630	+	return cbFn(arg0, arg1, arg2)
			631	+	}
			632	+	SortFuncVarRef = purego.NewCallback(fcb)
			633	+	glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
			634	+	}
			635	+	}
			636	+
			637	+	var DestroyVarRef uintptr
			638	+	if DestroyVar != nil {
			639	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			640	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			641	+	DestroyVarRef = cbRefPtr
			642	+	} else {
			643	+	fcb := func(arg0 uintptr) {
			644	+	cbFn := *DestroyVar
			645	+	cbFn(arg0)
			646	+	}
			647	+	DestroyVarRef = purego.NewCallback(fcb)
			648	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			649	+	}
			650	+	}
			651	+
			652	+	xFlowBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)
548			653
549		}	654		}
550			655

M v4/gtk/gtkfontbutton.go +1 -1


@@ -193,7 +193,7 @@ func (x *FontButton) GetPropertyModal() bool {
193		func (x *FontButton) SetPropertyTitle(value string) {	193		func (x *FontButton) SetPropertyTitle(value string) {
194		var v gobject.Value	194		var v gobject.Value
195		v.Init(gobject.TypeStringVal)	195		v.Init(gobject.TypeStringVal)
196	-	v.SetString(value)	196	+	v.SetString(&value)
197		x.SetProperty("title", &v)	197		x.SetProperty("title", &v)
198		}	198		}
199			199

M v4/gtk/gtkfontchooser.go +3 -3


@@ -507,7 +507,7 @@ func (x *FontChooserBase) SetPropertyFont(value string) {
507		obj.Ptr = x.GoPointer()	507		obj.Ptr = x.GoPointer()
508		var v gobject.Value	508		var v gobject.Value
509		v.Init(gobject.TypeStringVal)	509		v.Init(gobject.TypeStringVal)
510	-	v.SetString(value)	510	+	v.SetString(&value)
511		obj.SetProperty("font", &v)	511		obj.SetProperty("font", &v)
512		}	512		}
513			513

@@ -562,7 +562,7 @@ func (x *FontChooserBase) SetPropertyLanguage(value string) {
562		obj.Ptr = x.GoPointer()	562		obj.Ptr = x.GoPointer()
563		var v gobject.Value	563		var v gobject.Value
564		v.Init(gobject.TypeStringVal)	564		v.Init(gobject.TypeStringVal)
565	-	v.SetString(value)	565	+	v.SetString(&value)
566		obj.SetProperty("language", &v)	566		obj.SetProperty("language", &v)
567		}	567		}
568			568

@@ -583,7 +583,7 @@ func (x *FontChooserBase) SetPropertyPreviewText(value string) {
583		obj.Ptr = x.GoPointer()	583		obj.Ptr = x.GoPointer()
584		var v gobject.Value	584		var v gobject.Value
585		v.Init(gobject.TypeStringVal)	585		v.Init(gobject.TypeStringVal)
586	-	v.SetString(value)	586	+	v.SetString(&value)
587		obj.SetProperty("preview-text", &v)	587		obj.SetProperty("preview-text", &v)
588		}	588		}
589			589

M v4/gtk/gtkfontchooserdialog.go +3 -3


@@ -52,13 +52,13 @@ func FontChooserDialogNewFromInternalPtr(ptr uintptr) *FontChooserDialog {
52		return cls	52		return cls
53		}	53		}
54			54
55	-	var xNewFontChooserDialog func(string, uintptr) uintptr	55	+	var xNewFontChooserDialog func(uintptr, uintptr) uintptr
56			56
57		// Creates a new `GtkFontChooserDialog`.	57		// Creates a new `GtkFontChooserDialog`.
58	-	func NewFontChooserDialog(TitleVar string, ParentVar Window) FontChooserDialog {	58	+	func NewFontChooserDialog(TitleVar string, ParentVar Window) *FontChooserDialog {
59		var cls *FontChooserDialog	59		var cls *FontChooserDialog
60			60
61	-	cret := xNewFontChooserDialog(TitleVar, ParentVar.GoPointer())	61	+	cret := xNewFontChooserDialog(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer())
62			62
63		if cret == 0 {	63		if cret == 0 {
64		return nil	64		return nil

M v4/gtk/gtkfontdialog.go +65 -5


@@ -76,7 +76,22 @@ var xFontDialogChooseFace func(uintptr, uintptr, uintptr, uintptr, uintptr, uint
76		// A font face represents a font family and style, but no specific font size.	76		// A font face represents a font family and style, but no specific font size.
77		func (x FontDialog) ChooseFace(ParentVar Window, InitialValueVar pango.FontFace, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	77		func (x FontDialog) ChooseFace(ParentVar Window, InitialValueVar pango.FontFace, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
78			78
79	-	xFontDialogChooseFace(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	79	+	var CallbackVarRef uintptr
			80	+	if CallbackVar != nil {
			81	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			82	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			83	+	CallbackVarRef = cbRefPtr
			84	+	} else {
			85	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			86	+	cbFn := *CallbackVar
			87	+	cbFn(arg0, arg1, arg2)
			88	+	}
			89	+	CallbackVarRef = purego.NewCallback(fcb)
			90	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			91	+	}
			92	+	}
			93	+
			94	+	xFontDialogChooseFace(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
80			95
81		}	96		}
82			97

@@ -111,7 +126,22 @@ var xFontDialogChooseFamily func(uintptr, uintptr, uintptr, uintptr, uintptr, ui
111		// The font chooser dialog will be set up for selecting a font family.	126		// The font chooser dialog will be set up for selecting a font family.
112		func (x FontDialog) ChooseFamily(ParentVar Window, InitialValueVar pango.FontFamily, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	127		func (x FontDialog) ChooseFamily(ParentVar Window, InitialValueVar pango.FontFamily, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
113			128
114	-	xFontDialogChooseFamily(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	129	+	var CallbackVarRef uintptr
			130	+	if CallbackVar != nil {
			131	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			132	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			133	+	CallbackVarRef = cbRefPtr
			134	+	} else {
			135	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			136	+	cbFn := *CallbackVar
			137	+	cbFn(arg0, arg1, arg2)
			138	+	}
			139	+	CallbackVarRef = purego.NewCallback(fcb)
			140	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			141	+	}
			142	+	}
			143	+
			144	+	xFontDialogChooseFamily(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
115			145
116		}	146		}
117			147

@@ -149,7 +179,22 @@ var xFontDialogChooseFont func(uintptr, uintptr, *pango.FontDescription, uintptr
149		// use [method@Gtk.FontDialog.choose_font_and_features] instead.	179		// use [method@Gtk.FontDialog.choose_font_and_features] instead.
150		func (x FontDialog) ChooseFont(ParentVar Window, InitialValueVar pango.FontDescription, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	180		func (x FontDialog) ChooseFont(ParentVar Window, InitialValueVar pango.FontDescription, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
151			181
152	-	xFontDialogChooseFont(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	182	+	var CallbackVarRef uintptr
			183	+	if CallbackVar != nil {
			184	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			185	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			186	+	CallbackVarRef = cbRefPtr
			187	+	} else {
			188	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			189	+	cbFn := *CallbackVar
			190	+	cbFn(arg0, arg1, arg2)
			191	+	}
			192	+	CallbackVarRef = purego.NewCallback(fcb)
			193	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			194	+	}
			195	+	}
			196	+
			197	+	xFontDialogChooseFont(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
153			198
154		}	199		}
155			200

@@ -164,7 +209,22 @@ var xFontDialogChooseFontAndFeatures func(uintptr, uintptr, *pango.FontDescripti
164		// enabling glyph variants or ligatures.	209		// enabling glyph variants or ligatures.
165		func (x FontDialog) ChooseFontAndFeatures(ParentVar Window, InitialValueVar pango.FontDescription, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	210		func (x FontDialog) ChooseFontAndFeatures(ParentVar Window, InitialValueVar pango.FontDescription, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
166			211
167	-	xFontDialogChooseFontAndFeatures(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	212	+	var CallbackVarRef uintptr
			213	+	if CallbackVar != nil {
			214	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			215	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			216	+	CallbackVarRef = cbRefPtr
			217	+	} else {
			218	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			219	+	cbFn := *CallbackVar
			220	+	cbFn(arg0, arg1, arg2)
			221	+	}
			222	+	CallbackVarRef = purego.NewCallback(fcb)
			223	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			224	+	}
			225	+	}
			226	+
			227	+	xFontDialogChooseFontAndFeatures(x.GoPointer(), ParentVar.GoPointer(), InitialValueVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
168			228
169		}	229		}
170			230

@@ -372,7 +432,7 @@ func (x *FontDialog) GetPropertyModal() bool {
372		func (x *FontDialog) SetPropertyTitle(value string) {	432		func (x *FontDialog) SetPropertyTitle(value string) {
373		var v gobject.Value	433		var v gobject.Value
374		v.Init(gobject.TypeStringVal)	434		v.Init(gobject.TypeStringVal)
375	-	v.SetString(value)	435	+	v.SetString(&value)
376		x.SetProperty("title", &v)	436		x.SetProperty("title", &v)
377		}	437		}
378			438

M v4/gtk/gtkfontdialogbutton.go +4 -4


@@ -212,12 +212,12 @@ func (x FontDialogButton) SetFontDesc(FontDescVar pango.FontDescription) {
212			212
213		}	213		}
214			214
215	-	var xFontDialogButtonSetFontFeatures func(uintptr, string)	215	+	var xFontDialogButtonSetFontFeatures func(uintptr, uintptr)
216			216
217		// Sets the font features of the button.	217		// Sets the font features of the button.
218	-	func (x *FontDialogButton) SetFontFeatures(FontFeaturesVar string) {	218	+	func (x FontDialogButton) SetFontFeatures(FontFeaturesVar string) {
219			219
220	-	xFontDialogButtonSetFontFeatures(x.GoPointer(), FontFeaturesVar)	220	+	xFontDialogButtonSetFontFeatures(x.GoPointer(), core.NullableStringToPtr(FontFeaturesVar))
221			221
222		}	222		}
223			223

@@ -313,7 +313,7 @@ func (x *FontDialogButton) GetPropertyFontDesc() uintptr {
313		func (x *FontDialogButton) SetPropertyFontFeatures(value string) {	313		func (x *FontDialogButton) SetPropertyFontFeatures(value string) {
314		var v gobject.Value	314		var v gobject.Value
315		v.Init(gobject.TypeStringVal)	315		v.Init(gobject.TypeStringVal)
316	-	v.SetString(value)	316	+	v.SetString(&value)
317		x.SetProperty("font-features", &v)	317		x.SetProperty("font-features", &v)
318		}	318		}
319			319

M v4/gtk/gtkframe.go +7 -7


@@ -112,15 +112,15 @@ func FrameNewFromInternalPtr(ptr uintptr) *Frame {
112		return cls	112		return cls
113		}	113		}
114			114
115	-	var xNewFrame func(string) uintptr	115	+	var xNewFrame func(uintptr) uintptr
116			116
117		// Creates a new `GtkFrame`, with optional label @label.	117		// Creates a new `GtkFrame`, with optional label @label.
118		//	118		//
119		// If @label is %NULL, the label is omitted.	119		// If @label is %NULL, the label is omitted.
120	-	func NewFrame(LabelVar string) *Frame {	120	+	func NewFrame(LabelVar string) Frame {
121		var cls *Frame	121		var cls *Frame
122			122
123	-	cret := xNewFrame(LabelVar)	123	+	cret := xNewFrame(core.NullableStringToPtr(LabelVar))
124			124
125		if cret == 0 {	125		if cret == 0 {
126		return nil	126		return nil

@@ -195,13 +195,13 @@ func (x Frame) SetChild(ChildVar Widget) {
195			195
196		}	196		}
197			197
198	-	var xFrameSetLabel func(uintptr, string)	198	+	var xFrameSetLabel func(uintptr, uintptr)
199			199
200		// Creates a new `GtkLabel` with the @label and sets it as the frame's	200		// Creates a new `GtkLabel` with the @label and sets it as the frame's
201		// label widget.	201		// label widget.
202	-	func (x *Frame) SetLabel(LabelVar string) {	202	+	func (x Frame) SetLabel(LabelVar string) {
203			203
204	-	xFrameSetLabel(x.GoPointer(), LabelVar)	204	+	xFrameSetLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
205			205
206		}	206		}
207			207

@@ -244,7 +244,7 @@ func (c *Frame) SetGoPointer(ptr uintptr) {
244		func (x *Frame) SetPropertyLabel(value string) {	244		func (x *Frame) SetPropertyLabel(value string) {
245		var v gobject.Value	245		var v gobject.Value
246		v.Init(gobject.TypeStringVal)	246		v.Init(gobject.TypeStringVal)
247	-	v.SetString(value)	247	+	v.SetString(&value)
248		x.SetProperty("label", &v)	248		x.SetProperty("label", &v)
249		}	249		}
250			250

M v4/gtk/gtkheaderbar.go +4 -4


@@ -201,7 +201,7 @@ func (x HeaderBar) Remove(ChildVar Widget) {
201			201
202		}	202		}
203			203
204	-	var xHeaderBarSetDecorationLayout func(uintptr, string)	204	+	var xHeaderBarSetDecorationLayout func(uintptr, uintptr)
205			205
206		// Sets the decoration layout for this header bar.	206		// Sets the decoration layout for this header bar.
207		//	207		//

@@ -220,9 +220,9 @@ var xHeaderBarSetDecorationLayout func(uintptr, string)
220		//	220		//
221		// For example, “icon:minimize,maximize,close” specifies an icon	221		// For example, “icon:minimize,maximize,close” specifies an icon
222		// on the left, and minimize, maximize and close buttons on the right.	222		// on the left, and minimize, maximize and close buttons on the right.
223	-	func (x *HeaderBar) SetDecorationLayout(LayoutVar string) {	223	+	func (x HeaderBar) SetDecorationLayout(LayoutVar string) {
224			224
225	-	xHeaderBarSetDecorationLayout(x.GoPointer(), LayoutVar)	225	+	xHeaderBarSetDecorationLayout(x.GoPointer(), core.NullableStringToPtr(LayoutVar))
226			226
227		}	227		}
228			228

@@ -288,7 +288,7 @@ func (c *HeaderBar) SetGoPointer(ptr uintptr) {
288		func (x *HeaderBar) SetPropertyDecorationLayout(value string) {	288		func (x *HeaderBar) SetPropertyDecorationLayout(value string) {
289		var v gobject.Value	289		var v gobject.Value
290		v.Init(gobject.TypeStringVal)	290		v.Init(gobject.TypeStringVal)
291	-	v.SetString(value)	291	+	v.SetString(&value)
292		x.SetProperty("decoration-layout", &v)	292		x.SetProperty("decoration-layout", &v)
293		}	293		}
294			294

M v4/gtk/gtkiconpaintable.go +1 -1


@@ -124,7 +124,7 @@ func (c *IconPaintable) SetGoPointer(ptr uintptr) {
124		func (x *IconPaintable) SetPropertyIconName(value string) {	124		func (x *IconPaintable) SetPropertyIconName(value string) {
125		var v gobject.Value	125		var v gobject.Value
126		v.Init(gobject.TypeStringVal)	126		v.Init(gobject.TypeStringVal)
127	-	v.SetString(value)	127	+	v.SetString(&value)
128		x.SetProperty("icon-name", &v)	128		x.SetProperty("icon-name", &v)
129		}	129		}
130			130

M v4/gtk/gtkicontheme.go +4 -4


@@ -343,16 +343,16 @@ func (x *IconTheme) SetSearchPath(PathVar []string) {
343			343
344		}	344		}
345			345
346	-	var xIconThemeSetThemeName func(uintptr, string)	346	+	var xIconThemeSetThemeName func(uintptr, uintptr)
347			347
348		// Sets the name of the icon theme that the `GtkIconTheme` object uses	348		// Sets the name of the icon theme that the `GtkIconTheme` object uses
349		// overriding system configuration.	349		// overriding system configuration.
350		//	350		//
351		// This function cannot be called on the icon theme objects returned	351		// This function cannot be called on the icon theme objects returned
352		// from [func@Gtk.IconTheme.get_for_display].	352		// from [func@Gtk.IconTheme.get_for_display].
353	-	func (x *IconTheme) SetThemeName(ThemeNameVar string) {	353	+	func (x IconTheme) SetThemeName(ThemeNameVar string) {
354			354
355	-	xIconThemeSetThemeName(x.GoPointer(), ThemeNameVar)	355	+	xIconThemeSetThemeName(x.GoPointer(), core.NullableStringToPtr(ThemeNameVar))
356			356
357		}	357		}
358			358

@@ -444,7 +444,7 @@ func (x *IconTheme) GetPropertySearchPath() []string {
444		func (x *IconTheme) SetPropertyThemeName(value string) {	444		func (x *IconTheme) SetPropertyThemeName(value string) {
445		var v gobject.Value	445		var v gobject.Value
446		v.Init(gobject.TypeStringVal)	446		v.Init(gobject.TypeStringVal)
447	-	v.SetString(value)	447	+	v.SetString(&value)
448		x.SetProperty("theme-name", &v)	448		x.SetProperty("theme-name", &v)
449		}	449		}
450			450

M v4/gtk/gtkiconview.go +16 -1


@@ -536,7 +536,22 @@ var xIconViewSelectedForeach func(uintptr, uintptr, uintptr)
536		// selection cannot be modified from within this function.	536		// selection cannot be modified from within this function.
537		func (x IconView) SelectedForeach(FuncVar IconViewForeachFunc, DataVar uintptr) {	537		func (x IconView) SelectedForeach(FuncVar IconViewForeachFunc, DataVar uintptr) {
538			538
539	-	xIconViewSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)	539	+	var FuncVarRef uintptr
			540	+	if FuncVar != nil {
			541	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			542	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			543	+	FuncVarRef = cbRefPtr
			544	+	} else {
			545	+	fcb := func(arg0 uintptr, arg1 *TreePath, arg2 uintptr) {
			546	+	cbFn := *FuncVar
			547	+	cbFn(arg0, arg1, arg2)
			548	+	}
			549	+	FuncVarRef = purego.NewCallback(fcb)
			550	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			551	+	}
			552	+	}
			553	+
			554	+	xIconViewSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
540			555
541		}	556		}
542			557

M v4/gtk/gtkimage.go +15 -15


@@ -166,17 +166,17 @@ func NewImageFromGicon(IconVar gio.Icon) *Image {
166		return cls	166		return cls
167		}	167		}
168			168
169	-	var xNewImageFromIconName func(string) uintptr	169	+	var xNewImageFromIconName func(uintptr) uintptr
170			170
171		// Creates a `GtkImage` displaying an icon from the current icon theme.	171		// Creates a `GtkImage` displaying an icon from the current icon theme.
172		//	172		//
173		// If the icon name isn’t known, a “broken image” icon will be	173		// If the icon name isn’t known, a “broken image” icon will be
174		// displayed instead. If the current icon theme is changed, the icon	174		// displayed instead. If the current icon theme is changed, the icon
175		// will be updated appropriately.	175		// will be updated appropriately.
176	-	func NewImageFromIconName(IconNameVar string) *Image {	176	+	func NewImageFromIconName(IconNameVar string) Image {
177		var cls *Image	177		var cls *Image
178			178
179	-	cret := xNewImageFromIconName(IconNameVar)	179	+	cret := xNewImageFromIconName(core.NullableStringToPtr(IconNameVar))
180			180
181		if cret == 0 {	181		if cret == 0 {
182		return nil	182		return nil

@@ -373,7 +373,7 @@ func (x *Image) GetStorageType() ImageType {
373		return cret	373		return cret
374		}	374		}
375			375
376	-	var xImageSetFromFile func(uintptr, string)	376	+	var xImageSetFromFile func(uintptr, uintptr)
377			377
378		// Sets a `GtkImage` to show a file.	378		// Sets a `GtkImage` to show a file.
379		//	379		//

@@ -385,9 +385,9 @@ var xImageSetFromFile func(uintptr, string)
385		// Use a proper image loading framework such as libglycin, which can	385		// Use a proper image loading framework such as libglycin, which can
386		// load many image formats into a `GdkTexture`, and then use	386		// load many image formats into a `GdkTexture`, and then use
387		// [method@Gtk.Image.set_from_paintable].	387		// [method@Gtk.Image.set_from_paintable].
388	-	func (x *Image) SetFromFile(FilenameVar string) {	388	+	func (x Image) SetFromFile(FilenameVar string) {
389			389
390	-	xImageSetFromFile(x.GoPointer(), FilenameVar)	390	+	xImageSetFromFile(x.GoPointer(), core.NullableStringToPtr(FilenameVar))
391			391
392		}	392		}
393			393

@@ -402,14 +402,14 @@ func (x *Image) SetFromGicon(IconVar gio.Icon) {
402			402
403		}	403		}
404			404
405	-	var xImageSetFromIconName func(uintptr, string)	405	+	var xImageSetFromIconName func(uintptr, uintptr)
406			406
407		// Sets a `GtkImage` to show a named icon.	407		// Sets a `GtkImage` to show a named icon.
408		//	408		//
409		// See [ctor@Gtk.Image.new_from_icon_name] for details.	409		// See [ctor@Gtk.Image.new_from_icon_name] for details.
410	-	func (x *Image) SetFromIconName(IconNameVar string) {	410	+	func (x Image) SetFromIconName(IconNameVar string) {
411			411
412	-	xImageSetFromIconName(x.GoPointer(), IconNameVar)	412	+	xImageSetFromIconName(x.GoPointer(), core.NullableStringToPtr(IconNameVar))
413			413
414		}	414		}
415			415

@@ -439,14 +439,14 @@ func (x Image) SetFromPixbuf(PixbufVar gdkpixbuf.Pixbuf) {
439			439
440		}	440		}
441			441
442	-	var xImageSetFromResource func(uintptr, string)	442	+	var xImageSetFromResource func(uintptr, uintptr)
443			443
444		// Sets a `GtkImage` to show a resource.	444		// Sets a `GtkImage` to show a resource.
445		//	445		//
446		// See [ctor@Gtk.Image.new_from_resource] for details.	446		// See [ctor@Gtk.Image.new_from_resource] for details.
447	-	func (x *Image) SetFromResource(ResourcePathVar string) {	447	+	func (x Image) SetFromResource(ResourcePathVar string) {
448			448
449	-	xImageSetFromResource(x.GoPointer(), ResourcePathVar)	449	+	xImageSetFromResource(x.GoPointer(), core.NullableStringToPtr(ResourcePathVar))
450			450
451		}	451		}
452			452

@@ -487,7 +487,7 @@ func (c *Image) SetGoPointer(ptr uintptr) {
487		func (x *Image) SetPropertyFile(value string) {	487		func (x *Image) SetPropertyFile(value string) {
488		var v gobject.Value	488		var v gobject.Value
489		v.Init(gobject.TypeStringVal)	489		v.Init(gobject.TypeStringVal)
490	-	v.SetString(value)	490	+	v.SetString(&value)
491		x.SetProperty("file", &v)	491		x.SetProperty("file", &v)
492		}	492		}
493			493

@@ -506,7 +506,7 @@ func (x *Image) GetPropertyFile() string {
506		func (x *Image) SetPropertyIconName(value string) {	506		func (x *Image) SetPropertyIconName(value string) {
507		var v gobject.Value	507		var v gobject.Value
508		v.Init(gobject.TypeStringVal)	508		v.Init(gobject.TypeStringVal)
509	-	v.SetString(value)	509	+	v.SetString(&value)
510		x.SetProperty("icon-name", &v)	510		x.SetProperty("icon-name", &v)
511		}	511		}
512			512

@@ -550,7 +550,7 @@ func (x *Image) GetPropertyPixelSize() int {
550		func (x *Image) SetPropertyResource(value string) {	550		func (x *Image) SetPropertyResource(value string) {
551		var v gobject.Value	551		var v gobject.Value
552		v.Init(gobject.TypeStringVal)	552		v.Init(gobject.TypeStringVal)
553	-	v.SetString(value)	553	+	v.SetString(&value)
554		x.SetProperty("resource", &v)	554		x.SetProperty("resource", &v)
555		}	555		}
556			556

M v4/gtk/gtkimmulticontext.go +3 -3


@@ -174,7 +174,7 @@ func (x *IMMulticontext) GetContextId() string {
174		return cret	174		return cret
175		}	175		}
176			176
177	-	var xIMMulticontextSetContextId func(uintptr, string)	177	+	var xIMMulticontextSetContextId func(uintptr, uintptr)
178			178
179		// Sets the context id for @context.	179		// Sets the context id for @context.
180		//	180		//

@@ -184,9 +184,9 @@ var xIMMulticontextSetContextId func(uintptr, string)
184		// Setting this to a non-%NULL value overrides the system-wide	184		// Setting this to a non-%NULL value overrides the system-wide
185		// IM module setting. See the [property@Gtk.Settings:gtk-im-module]	185		// IM module setting. See the [property@Gtk.Settings:gtk-im-module]
186		// property.	186		// property.
187	-	func (x *IMMulticontext) SetContextId(ContextIdVar string) {	187	+	func (x IMMulticontext) SetContextId(ContextIdVar string) {
188			188
189	-	xIMMulticontextSetContextId(x.GoPointer(), ContextIdVar)	189	+	xIMMulticontextSetContextId(x.GoPointer(), core.NullableStringToPtr(ContextIdVar))
190			190
191		}	191		}
192			192

M v4/gtk/gtkinfobar.go +3 -3


@@ -127,7 +127,7 @@ func NewInfoBar() *InfoBar {
127		return cls	127		return cls
128		}	128		}
129			129
130	-	var xNewInfoBarWithButtons func(string, ...interface{}) uintptr	130	+	var xNewInfoBarWithButtons func(uintptr, ...interface{}) uintptr
131			131
132		// Creates a new `GtkInfoBar` with buttons.	132		// Creates a new `GtkInfoBar` with buttons.
133		//	133		//

@@ -137,10 +137,10 @@ var xNewInfoBarWithButtons func(string, ...interface{}) uintptr
137		// user clicks one of these dialog buttons, GtkInfoBar will emit	137		// user clicks one of these dialog buttons, GtkInfoBar will emit
138		// the [signal@Gtk.InfoBar::response] signal with the corresponding	138		// the [signal@Gtk.InfoBar::response] signal with the corresponding
139		// response ID.	139		// response ID.
140	-	func NewInfoBarWithButtons(FirstButtonTextVar string, varArgs ...interface{}) *InfoBar {	140	+	func NewInfoBarWithButtons(FirstButtonTextVar string, varArgs ...interface{}) InfoBar {
141		var cls *InfoBar	141		var cls *InfoBar
142			142
143	-	cret := xNewInfoBarWithButtons(FirstButtonTextVar, varArgs...)	143	+	cret := xNewInfoBarWithButtons(core.NullableStringToPtr(FirstButtonTextVar), varArgs...)
144			144
145		if cret == 0 {	145		if cret == 0 {
146		return nil	146		return nil

M v4/gtk/gtkinscription.go +11 -11


@@ -76,13 +76,13 @@ func InscriptionNewFromInternalPtr(ptr uintptr) *Inscription {
76		return cls	76		return cls
77		}	77		}
78			78
79	-	var xNewInscription func(string) uintptr	79	+	var xNewInscription func(uintptr) uintptr
80			80
81		// Creates a new `GtkInscription` with the given text.	81		// Creates a new `GtkInscription` with the given text.
82	-	func NewInscription(TextVar string) *Inscription {	82	+	func NewInscription(TextVar string) Inscription {
83		var cls *Inscription	83		var cls *Inscription
84			84
85	-	cret := xNewInscription(TextVar)	85	+	cret := xNewInscription(core.NullableStringToPtr(TextVar))
86			86
87		if cret == 0 {	87		if cret == 0 {
88		return nil	88		return nil

@@ -208,14 +208,14 @@ func (x Inscription) SetAttributes(AttrsVar pango.AttrList) {
208			208
209		}	209		}
210			210
211	-	var xInscriptionSetMarkup func(uintptr, string)	211	+	var xInscriptionSetMarkup func(uintptr, uintptr)
212			212
213		// Utility function to set the text and attributes to be displayed.	213		// Utility function to set the text and attributes to be displayed.
214		//	214		//
215		// See the [property@Gtk.Inscription:markup] property.	215		// See the [property@Gtk.Inscription:markup] property.
216	-	func (x *Inscription) SetMarkup(MarkupVar string) {	216	+	func (x Inscription) SetMarkup(MarkupVar string) {
217			217
218	-	xInscriptionSetMarkup(x.GoPointer(), MarkupVar)	218	+	xInscriptionSetMarkup(x.GoPointer(), core.NullableStringToPtr(MarkupVar))
219			219
220		}	220		}
221			221

@@ -263,12 +263,12 @@ func (x *Inscription) SetNatLines(NatLinesVar uint) {
263			263
264		}	264		}
265			265
266	-	var xInscriptionSetText func(uintptr, string)	266	+	var xInscriptionSetText func(uintptr, uintptr)
267			267
268		// Sets the text to be displayed.	268		// Sets the text to be displayed.
269	-	func (x *Inscription) SetText(TextVar string) {	269	+	func (x Inscription) SetText(TextVar string) {
270			270
271	-	xInscriptionSetText(x.GoPointer(), TextVar)	271	+	xInscriptionSetText(x.GoPointer(), core.NullableStringToPtr(TextVar))
272			272
273		}	273		}
274			274

@@ -351,7 +351,7 @@ func (x *Inscription) GetPropertyAttributes() uintptr {
351		func (x *Inscription) SetPropertyMarkup(value string) {	351		func (x *Inscription) SetPropertyMarkup(value string) {
352		var v gobject.Value	352		var v gobject.Value
353		v.Init(gobject.TypeStringVal)	353		v.Init(gobject.TypeStringVal)
354	-	v.SetString(value)	354	+	v.SetString(&value)
355		x.SetProperty("markup", &v)	355		x.SetProperty("markup", &v)
356		}	356		}
357			357

@@ -494,7 +494,7 @@ func (x *Inscription) GetPropertyNatLines() uint {
494		func (x *Inscription) SetPropertyText(value string) {	494		func (x *Inscription) SetPropertyText(value string) {
495		var v gobject.Value	495		var v gobject.Value
496		v.Init(gobject.TypeStringVal)	496		v.Init(gobject.TypeStringVal)
497	-	v.SetString(value)	497	+	v.SetString(&value)
498		x.SetProperty("text", &v)	498		x.SetProperty("text", &v)
499		}	499		}
500			500

M v4/gtk/gtklabel.go +7 -7


@@ -249,15 +249,15 @@ func LabelNewFromInternalPtr(ptr uintptr) *Label {
249		return cls	249		return cls
250		}	250		}
251			251
252	-	var xNewLabel func(string) uintptr	252	+	var xNewLabel func(uintptr) uintptr
253			253
254		// Creates a new label with the given text inside it.	254		// Creates a new label with the given text inside it.
255		//	255		//
256		// You can pass `NULL` to get an empty label widget.	256		// You can pass `NULL` to get an empty label widget.
257	-	func NewLabel(StrVar string) *Label {	257	+	func NewLabel(StrVar string) Label {
258		var cls *Label	258		var cls *Label
259			259
260	-	cret := xNewLabel(StrVar)	260	+	cret := xNewLabel(core.NullableStringToPtr(StrVar))
261			261
262		if cret == 0 {	262		if cret == 0 {
263		return nil	263		return nil

@@ -268,7 +268,7 @@ func NewLabel(StrVar string) *Label {
268		return cls	268		return cls
269		}	269		}
270			270
271	-	var xNewLabelWithMnemonic func(string) uintptr	271	+	var xNewLabelWithMnemonic func(uintptr) uintptr
272			272
273		// Creates a new label with the given text inside it, and a mnemonic.	273		// Creates a new label with the given text inside it, and a mnemonic.
274		//	274		//

@@ -284,10 +284,10 @@ var xNewLabelWithMnemonic func(string) uintptr
284		// widget. For instance, if the label is inside a button or menu item,	284		// widget. For instance, if the label is inside a button or menu item,
285		// the button or menu item will automatically become the mnemonic widget	285		// the button or menu item will automatically become the mnemonic widget
286		// and be activated by the mnemonic.	286		// and be activated by the mnemonic.
287	-	func NewLabelWithMnemonic(StrVar string) *Label {	287	+	func NewLabelWithMnemonic(StrVar string) Label {
288		var cls *Label	288		var cls *Label
289			289
290	-	cret := xNewLabelWithMnemonic(StrVar)	290	+	cret := xNewLabelWithMnemonic(core.NullableStringToPtr(StrVar))
291			291
292		if cret == 0 {	292		if cret == 0 {
293		return nil	293		return nil

@@ -998,7 +998,7 @@ func (x *Label) GetPropertyAttributes() uintptr {
998		func (x *Label) SetPropertyLabel(value string) {	998		func (x *Label) SetPropertyLabel(value string) {
999		var v gobject.Value	999		var v gobject.Value
1000		v.Init(gobject.TypeStringVal)	1000		v.Init(gobject.TypeStringVal)
1001	-	v.SetString(value)	1001	+	v.SetString(&value)
1002		x.SetProperty("label", &v)	1002		x.SetProperty("label", &v)
1003		}	1003		}
1004			1004

M v4/gtk/gtklevelbar.go +29 -6

 package gtk
 import (
+	"fmt"
 	"unsafe"
 	"github.com/jwijenbergh/purego"
 	return cret
 }
-var xLevelBarGetOffsetValue func(uintptr, string, *float64) bool
+var xLevelBarGetOffsetValue func(uintptr, uintptr, *float64) bool
 // Fetches the value specified for the offset marker @name in @self.
-func (x *LevelBar) GetOffsetValue(NameVar string, ValueVar *float64) bool {
+func (x *LevelBar) GetOffsetValue(NameVar *string, ValueVar *float64) bool {
-	cret := xLevelBarGetOffsetValue(x.GoPointer(), NameVar, ValueVar)
+	cret := xLevelBarGetOffsetValue(x.GoPointer(), core.NullableStringToPtr(NameVar), ValueVar)
 	return cret
 }
 	return cret
 }
-var xLevelBarRemoveOffsetValue func(uintptr, string)
+var xLevelBarRemoveOffsetValue func(uintptr, uintptr)
 // Removes an offset marker from a `GtkLevelBar`.
 //
 // The marker must have been previously added with
 // [method@Gtk.LevelBar.add_offset_value].
-func (x *LevelBar) RemoveOffsetValue(NameVar string) {
+func (x *LevelBar) RemoveOffsetValue(NameVar *string) {
-	xLevelBarRemoveOffsetValue(x.GoPointer(), NameVar)
+	xLevelBarRemoveOffsetValue(x.GoPointer(), core.NullableStringToPtr(NameVar))
 }
 	return gobject.SignalConnect(x.GoPointer(), "offset-changed", cbRefPtr)
 }
+// ConnectOffsetChangedWithDetail connects to the "offset-changed" signal with a detail string.
+// The detail is appended as "offset-changed::<detail>".
+func (x *LevelBar) ConnectOffsetChangedWithDetail(detail string, cb *func(LevelBar, string)) uint32 {
+	cbPtr := uintptr(unsafe.Pointer(cb))
+	signalName := fmt.Sprintf("offset-changed::%s", detail)
+	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
+		return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+	}
+	fcb := func(clsPtr uintptr, NameVarp string) {
+		fa := LevelBar{}
+		fa.Ptr = clsPtr
+		cbFn := *cb
+		cbFn(fa, NameVarp)
+	}
+	cbRefPtr := purego.NewCallback(fcb)
+	glib.SaveCallback(cbPtr, cbRefPtr)
+	return gobject.SignalConnect(x.GoPointer(), signalName, cbRefPtr)
+}
 // Requests the user's screen reader to announce the given message.
 //
 // This kind of notification is useful for messages that

M v4/gtk/gtklinkbutton.go +6 -6


@@ -88,13 +88,13 @@ func NewLinkButton(UriVar string) *LinkButton {
88		return cls	88		return cls
89		}	89		}
90			90
91	-	var xNewLinkButtonWithLabel func(string, string) uintptr	91	+	var xNewLinkButtonWithLabel func(string, uintptr) uintptr
92			92
93		// Creates a new `GtkLinkButton` containing a label.	93		// Creates a new `GtkLinkButton` containing a label.
94	-	func NewLinkButtonWithLabel(UriVar string, LabelVar string) *LinkButton {	94	+	func NewLinkButtonWithLabel(UriVar string, LabelVar string) LinkButton {
95		var cls *LinkButton	95		var cls *LinkButton
96			96
97	-	cret := xNewLinkButtonWithLabel(UriVar, LabelVar)	97	+	cret := xNewLinkButtonWithLabel(UriVar, core.NullableStringToPtr(LabelVar))
98			98
99		if cret == 0 {	99		if cret == 0 {
100		return nil	100		return nil

@@ -166,7 +166,7 @@ func (c *LinkButton) SetGoPointer(ptr uintptr) {
166		func (x *LinkButton) SetPropertyUri(value string) {	166		func (x *LinkButton) SetPropertyUri(value string) {
167		var v gobject.Value	167		var v gobject.Value
168		v.Init(gobject.TypeStringVal)	168		v.Init(gobject.TypeStringVal)
169	-	v.SetString(value)	169	+	v.SetString(&value)
170		x.SetProperty("uri", &v)	170		x.SetProperty("uri", &v)
171		}	171		}
172			172

@@ -521,9 +521,9 @@ func (x LinkButton) GetActionTargetValue() glib.Variant {
521		// containing [class@ApplicationWindow] or its associated [class@Application],	521		// containing [class@ApplicationWindow] or its associated [class@Application],
522		// respectively. This is the same form used for actions in the [class@Gio.Menu]	522		// respectively. This is the same form used for actions in the [class@Gio.Menu]
523		// associated with the window.	523		// associated with the window.
524	-	func (x *LinkButton) SetActionName(ActionNameVar string) {	524	+	func (x LinkButton) SetActionName(ActionNameVar string) {
525			525
526	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	526	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
527			527
528		}	528		}
529			529

M v4/gtk/gtklistbox.go +142 -7


@@ -209,7 +209,37 @@ var xListBoxBindModel func(uintptr, uintptr, uintptr, uintptr, uintptr)
209		// should be implemented by the model.	209		// should be implemented by the model.
210		func (x ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {	210		func (x ListBox) BindModel(ModelVar gio.ListModel, CreateWidgetFuncVar ListBoxCreateWidgetFunc, UserDataVar uintptr, UserDataFreeFuncVar *glib.DestroyNotify) {
211			211
212	-	xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), glib.NewCallbackNullable(CreateWidgetFuncVar), UserDataVar, glib.NewCallback(UserDataFreeFuncVar))	212	+	var CreateWidgetFuncVarRef uintptr
			213	+	if CreateWidgetFuncVar != nil {
			214	+	CreateWidgetFuncVarPtr := uintptr(unsafe.Pointer(CreateWidgetFuncVar))
			215	+	if cbRefPtr, ok := glib.GetCallback(CreateWidgetFuncVarPtr); ok {
			216	+	CreateWidgetFuncVarRef = cbRefPtr
			217	+	} else {
			218	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			219	+	cbFn := *CreateWidgetFuncVar
			220	+	return cbFn(arg0, arg1)
			221	+	}
			222	+	CreateWidgetFuncVarRef = purego.NewCallback(fcb)
			223	+	glib.SaveCallback(CreateWidgetFuncVarPtr, CreateWidgetFuncVarRef)
			224	+	}
			225	+	}
			226	+
			227	+	var UserDataFreeFuncVarRef uintptr
			228	+	if UserDataFreeFuncVar != nil {
			229	+	UserDataFreeFuncVarPtr := uintptr(unsafe.Pointer(UserDataFreeFuncVar))
			230	+	if cbRefPtr, ok := glib.GetCallback(UserDataFreeFuncVarPtr); ok {
			231	+	UserDataFreeFuncVarRef = cbRefPtr
			232	+	} else {
			233	+	fcb := func(arg0 uintptr) {
			234	+	cbFn := *UserDataFreeFuncVar
			235	+	cbFn(arg0)
			236	+	}
			237	+	UserDataFreeFuncVarRef = purego.NewCallback(fcb)
			238	+	glib.SaveCallback(UserDataFreeFuncVarPtr, UserDataFreeFuncVarRef)
			239	+	}
			240	+	}
			241	+
			242	+	xListBoxBindModel(x.GoPointer(), ModelVar.GoPointer(), CreateWidgetFuncVarRef, UserDataVar, UserDataFreeFuncVarRef)
213			243
214		}	244		}
215			245

@@ -475,7 +505,22 @@ var xListBoxSelectedForeach func(uintptr, uintptr, uintptr)
475		// Note that the selection cannot be modified from within this function.	505		// Note that the selection cannot be modified from within this function.
476		func (x ListBox) SelectedForeach(FuncVar ListBoxForeachFunc, DataVar uintptr) {	506		func (x ListBox) SelectedForeach(FuncVar ListBoxForeachFunc, DataVar uintptr) {
477			507
478	-	xListBoxSelectedForeach(x.GoPointer(), glib.NewCallback(FuncVar), DataVar)	508	+	var FuncVarRef uintptr
			509	+	if FuncVar != nil {
			510	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			511	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			512	+	FuncVarRef = cbRefPtr
			513	+	} else {
			514	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			515	+	cbFn := *FuncVar
			516	+	cbFn(arg0, arg1, arg2)
			517	+	}
			518	+	FuncVarRef = purego.NewCallback(fcb)
			519	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			520	+	}
			521	+	}
			522	+
			523	+	xListBoxSelectedForeach(x.GoPointer(), FuncVarRef, DataVar)
479			524
480		}	525		}
481			526

@@ -524,7 +569,37 @@ var xListBoxSetFilterFunc func(uintptr, uintptr, uintptr, uintptr)
524		// (see [method@Gtk.ListBox.bind_model]).	569		// (see [method@Gtk.ListBox.bind_model]).
525		func (x ListBox) SetFilterFunc(FilterFuncVar ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	570		func (x ListBox) SetFilterFunc(FilterFuncVar ListBoxFilterFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
526			571
527	-	xListBoxSetFilterFunc(x.GoPointer(), glib.NewCallbackNullable(FilterFuncVar), UserDataVar, glib.NewCallback(DestroyVar))	572	+	var FilterFuncVarRef uintptr
			573	+	if FilterFuncVar != nil {
			574	+	FilterFuncVarPtr := uintptr(unsafe.Pointer(FilterFuncVar))
			575	+	if cbRefPtr, ok := glib.GetCallback(FilterFuncVarPtr); ok {
			576	+	FilterFuncVarRef = cbRefPtr
			577	+	} else {
			578	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			579	+	cbFn := *FilterFuncVar
			580	+	return cbFn(arg0, arg1)
			581	+	}
			582	+	FilterFuncVarRef = purego.NewCallback(fcb)
			583	+	glib.SaveCallback(FilterFuncVarPtr, FilterFuncVarRef)
			584	+	}
			585	+	}
			586	+
			587	+	var DestroyVarRef uintptr
			588	+	if DestroyVar != nil {
			589	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			590	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			591	+	DestroyVarRef = cbRefPtr
			592	+	} else {
			593	+	fcb := func(arg0 uintptr) {
			594	+	cbFn := *DestroyVar
			595	+	cbFn(arg0)
			596	+	}
			597	+	DestroyVarRef = purego.NewCallback(fcb)
			598	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			599	+	}
			600	+	}
			601	+
			602	+	xListBoxSetFilterFunc(x.GoPointer(), FilterFuncVarRef, UserDataVar, DestroyVarRef)
528			603
529		}	604		}
530			605

@@ -557,7 +632,37 @@ var xListBoxSetHeaderFunc func(uintptr, uintptr, uintptr, uintptr)
557		// [method@Gtk.ListBox.invalidate_headers] is called.	632		// [method@Gtk.ListBox.invalidate_headers] is called.
558		func (x ListBox) SetHeaderFunc(UpdateHeaderVar ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	633		func (x ListBox) SetHeaderFunc(UpdateHeaderVar ListBoxUpdateHeaderFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
559			634
560	-	xListBoxSetHeaderFunc(x.GoPointer(), glib.NewCallbackNullable(UpdateHeaderVar), UserDataVar, glib.NewCallback(DestroyVar))	635	+	var UpdateHeaderVarRef uintptr
			636	+	if UpdateHeaderVar != nil {
			637	+	UpdateHeaderVarPtr := uintptr(unsafe.Pointer(UpdateHeaderVar))
			638	+	if cbRefPtr, ok := glib.GetCallback(UpdateHeaderVarPtr); ok {
			639	+	UpdateHeaderVarRef = cbRefPtr
			640	+	} else {
			641	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			642	+	cbFn := *UpdateHeaderVar
			643	+	cbFn(arg0, arg1, arg2)
			644	+	}
			645	+	UpdateHeaderVarRef = purego.NewCallback(fcb)
			646	+	glib.SaveCallback(UpdateHeaderVarPtr, UpdateHeaderVarRef)
			647	+	}
			648	+	}
			649	+
			650	+	var DestroyVarRef uintptr
			651	+	if DestroyVar != nil {
			652	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			653	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			654	+	DestroyVarRef = cbRefPtr
			655	+	} else {
			656	+	fcb := func(arg0 uintptr) {
			657	+	cbFn := *DestroyVar
			658	+	cbFn(arg0)
			659	+	}
			660	+	DestroyVarRef = purego.NewCallback(fcb)
			661	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			662	+	}
			663	+	}
			664	+
			665	+	xListBoxSetHeaderFunc(x.GoPointer(), UpdateHeaderVarRef, UserDataVar, DestroyVarRef)
561			666
562		}	667		}
563			668

@@ -606,7 +711,37 @@ var xListBoxSetSortFunc func(uintptr, uintptr, uintptr, uintptr)
606		// (see [method@Gtk.ListBox.bind_model]).	711		// (see [method@Gtk.ListBox.bind_model]).
607		func (x ListBox) SetSortFunc(SortFuncVar ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {	712		func (x ListBox) SetSortFunc(SortFuncVar ListBoxSortFunc, UserDataVar uintptr, DestroyVar *glib.DestroyNotify) {
608			713
609	-	xListBoxSetSortFunc(x.GoPointer(), glib.NewCallbackNullable(SortFuncVar), UserDataVar, glib.NewCallback(DestroyVar))	714	+	var SortFuncVarRef uintptr
			715	+	if SortFuncVar != nil {
			716	+	SortFuncVarPtr := uintptr(unsafe.Pointer(SortFuncVar))
			717	+	if cbRefPtr, ok := glib.GetCallback(SortFuncVarPtr); ok {
			718	+	SortFuncVarRef = cbRefPtr
			719	+	} else {
			720	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) int {
			721	+	cbFn := *SortFuncVar
			722	+	return cbFn(arg0, arg1, arg2)
			723	+	}
			724	+	SortFuncVarRef = purego.NewCallback(fcb)
			725	+	glib.SaveCallback(SortFuncVarPtr, SortFuncVarRef)
			726	+	}
			727	+	}
			728	+
			729	+	var DestroyVarRef uintptr
			730	+	if DestroyVar != nil {
			731	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			732	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			733	+	DestroyVarRef = cbRefPtr
			734	+	} else {
			735	+	fcb := func(arg0 uintptr) {
			736	+	cbFn := *DestroyVar
			737	+	cbFn(arg0)
			738	+	}
			739	+	DestroyVarRef = purego.NewCallback(fcb)
			740	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			741	+	}
			742	+	}
			743	+
			744	+	xListBoxSetSortFunc(x.GoPointer(), SortFuncVarRef, UserDataVar, DestroyVarRef)
610			745
611		}	746		}
612			747

@@ -1713,9 +1848,9 @@ func (x ListBoxRow) GetActionTargetValue() glib.Variant {
1713		// containing [class@ApplicationWindow] or its associated [class@Application],	1848		// containing [class@ApplicationWindow] or its associated [class@Application],
1714		// respectively. This is the same form used for actions in the [class@Gio.Menu]	1849		// respectively. This is the same form used for actions in the [class@Gio.Menu]
1715		// associated with the window.	1850		// associated with the window.
1716	-	func (x *ListBoxRow) SetActionName(ActionNameVar string) {	1851	+	func (x ListBoxRow) SetActionName(ActionNameVar string) {
1717			1852
1718	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	1853	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
1719			1854
1720		}	1855		}
1721			1856

M v4/gtk/gtklistitem.go +2 -2


@@ -264,7 +264,7 @@ func (c *ListItem) SetGoPointer(ptr uintptr) {
264		func (x *ListItem) SetPropertyAccessibleDescription(value string) {	264		func (x *ListItem) SetPropertyAccessibleDescription(value string) {
265		var v gobject.Value	265		var v gobject.Value
266		v.Init(gobject.TypeStringVal)	266		v.Init(gobject.TypeStringVal)
267	-	v.SetString(value)	267	+	v.SetString(&value)
268		x.SetProperty("accessible-description", &v)	268		x.SetProperty("accessible-description", &v)
269		}	269		}
270			270

@@ -281,7 +281,7 @@ func (x *ListItem) GetPropertyAccessibleDescription() string {
281		func (x *ListItem) SetPropertyAccessibleLabel(value string) {	281		func (x *ListItem) SetPropertyAccessibleLabel(value string) {
282		var v gobject.Value	282		var v gobject.Value
283		v.Init(gobject.TypeStringVal)	283		v.Init(gobject.TypeStringVal)
284	-	v.SetString(value)	284	+	v.SetString(&value)
285		x.SetProperty("accessible-label", &v)	285		x.SetProperty("accessible-label", &v)
286		}	286		}
287			287

M v4/gtk/gtklockbutton.go +7 -7


@@ -142,7 +142,7 @@ func (c *LockButton) SetGoPointer(ptr uintptr) {
142		func (x *LockButton) SetPropertyTextLock(value string) {	142		func (x *LockButton) SetPropertyTextLock(value string) {
143		var v gobject.Value	143		var v gobject.Value
144		v.Init(gobject.TypeStringVal)	144		v.Init(gobject.TypeStringVal)
145	-	v.SetString(value)	145	+	v.SetString(&value)
146		x.SetProperty("text-lock", &v)	146		x.SetProperty("text-lock", &v)
147		}	147		}
148			148

@@ -159,7 +159,7 @@ func (x *LockButton) GetPropertyTextLock() string {
159		func (x *LockButton) SetPropertyTextUnlock(value string) {	159		func (x *LockButton) SetPropertyTextUnlock(value string) {
160		var v gobject.Value	160		var v gobject.Value
161		v.Init(gobject.TypeStringVal)	161		v.Init(gobject.TypeStringVal)
162	-	v.SetString(value)	162	+	v.SetString(&value)
163		x.SetProperty("text-unlock", &v)	163		x.SetProperty("text-unlock", &v)
164		}	164		}
165			165

@@ -176,7 +176,7 @@ func (x *LockButton) GetPropertyTextUnlock() string {
176		func (x *LockButton) SetPropertyTooltipLock(value string) {	176		func (x *LockButton) SetPropertyTooltipLock(value string) {
177		var v gobject.Value	177		var v gobject.Value
178		v.Init(gobject.TypeStringVal)	178		v.Init(gobject.TypeStringVal)
179	-	v.SetString(value)	179	+	v.SetString(&value)
180		x.SetProperty("tooltip-lock", &v)	180		x.SetProperty("tooltip-lock", &v)
181		}	181		}
182			182

@@ -193,7 +193,7 @@ func (x *LockButton) GetPropertyTooltipLock() string {
193		func (x *LockButton) SetPropertyTooltipNotAuthorized(value string) {	193		func (x *LockButton) SetPropertyTooltipNotAuthorized(value string) {
194		var v gobject.Value	194		var v gobject.Value
195		v.Init(gobject.TypeStringVal)	195		v.Init(gobject.TypeStringVal)
196	-	v.SetString(value)	196	+	v.SetString(&value)
197		x.SetProperty("tooltip-not-authorized", &v)	197		x.SetProperty("tooltip-not-authorized", &v)
198		}	198		}
199			199

@@ -210,7 +210,7 @@ func (x *LockButton) GetPropertyTooltipNotAuthorized() string {
210		func (x *LockButton) SetPropertyTooltipUnlock(value string) {	210		func (x *LockButton) SetPropertyTooltipUnlock(value string) {
211		var v gobject.Value	211		var v gobject.Value
212		v.Init(gobject.TypeStringVal)	212		v.Init(gobject.TypeStringVal)
213	-	v.SetString(value)	213	+	v.SetString(&value)
214		x.SetProperty("tooltip-unlock", &v)	214		x.SetProperty("tooltip-unlock", &v)
215		}	215		}
216			216

@@ -517,9 +517,9 @@ func (x LockButton) GetActionTargetValue() glib.Variant {
517		// containing [class@ApplicationWindow] or its associated [class@Application],	517		// containing [class@ApplicationWindow] or its associated [class@Application],
518		// respectively. This is the same form used for actions in the [class@Gio.Menu]	518		// respectively. This is the same form used for actions in the [class@Gio.Menu]
519		// associated with the window.	519		// associated with the window.
520	-	func (x *LockButton) SetActionName(ActionNameVar string) {	520	+	func (x LockButton) SetActionName(ActionNameVar string) {
521			521
522	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	522	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
523			523
524		}	524		}
525			525

M v4/gtk/gtkmaplistmodel.go +62 -2


@@ -86,7 +86,37 @@ var xNewMapListModel func(uintptr, uintptr, uintptr, uintptr) uintptr
86		func NewMapListModel(ModelVar gio.ListModel, MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *MapListModel {	86		func NewMapListModel(ModelVar gio.ListModel, MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar glib.DestroyNotify) *MapListModel {
87		var cls *MapListModel	87		var cls *MapListModel
88			88
89	-	cret := xNewMapListModel(ModelVar.GoPointer(), glib.NewCallbackNullable(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))	89	+	var MapFuncVarRef uintptr
			90	+	if MapFuncVar != nil {
			91	+	MapFuncVarPtr := uintptr(unsafe.Pointer(MapFuncVar))
			92	+	if cbRefPtr, ok := glib.GetCallback(MapFuncVarPtr); ok {
			93	+	MapFuncVarRef = cbRefPtr
			94	+	} else {
			95	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			96	+	cbFn := *MapFuncVar
			97	+	return cbFn(arg0, arg1)
			98	+	}
			99	+	MapFuncVarRef = purego.NewCallback(fcb)
			100	+	glib.SaveCallback(MapFuncVarPtr, MapFuncVarRef)
			101	+	}
			102	+	}
			103	+
			104	+	var UserDestroyVarRef uintptr
			105	+	if UserDestroyVar != nil {
			106	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			107	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			108	+	UserDestroyVarRef = cbRefPtr
			109	+	} else {
			110	+	fcb := func(arg0 uintptr) {
			111	+	cbFn := *UserDestroyVar
			112	+	cbFn(arg0)
			113	+	}
			114	+	UserDestroyVarRef = purego.NewCallback(fcb)
			115	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			116	+	}
			117	+	}
			118	+
			119	+	cret := xNewMapListModel(ModelVar.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)
90			120
91		if cret == 0 {	121		if cret == 0 {
92		return nil	122		return nil

@@ -137,7 +167,37 @@ var xMapListModelSetMapFunc func(uintptr, uintptr, uintptr, uintptr)
137		// function returns items of the appropriate type.	167		// function returns items of the appropriate type.
138		func (x MapListModel) SetMapFunc(MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {	168		func (x MapListModel) SetMapFunc(MapFuncVar MapListModelMapFunc, UserDataVar uintptr, UserDestroyVar *glib.DestroyNotify) {
139			169
140	-	xMapListModelSetMapFunc(x.GoPointer(), glib.NewCallbackNullable(MapFuncVar), UserDataVar, glib.NewCallback(UserDestroyVar))	170	+	var MapFuncVarRef uintptr
			171	+	if MapFuncVar != nil {
			172	+	MapFuncVarPtr := uintptr(unsafe.Pointer(MapFuncVar))
			173	+	if cbRefPtr, ok := glib.GetCallback(MapFuncVarPtr); ok {
			174	+	MapFuncVarRef = cbRefPtr
			175	+	} else {
			176	+	fcb := func(arg0 uintptr, arg1 uintptr) uintptr {
			177	+	cbFn := *MapFuncVar
			178	+	return cbFn(arg0, arg1)
			179	+	}
			180	+	MapFuncVarRef = purego.NewCallback(fcb)
			181	+	glib.SaveCallback(MapFuncVarPtr, MapFuncVarRef)
			182	+	}
			183	+	}
			184	+
			185	+	var UserDestroyVarRef uintptr
			186	+	if UserDestroyVar != nil {
			187	+	UserDestroyVarPtr := uintptr(unsafe.Pointer(UserDestroyVar))
			188	+	if cbRefPtr, ok := glib.GetCallback(UserDestroyVarPtr); ok {
			189	+	UserDestroyVarRef = cbRefPtr
			190	+	} else {
			191	+	fcb := func(arg0 uintptr) {
			192	+	cbFn := *UserDestroyVar
			193	+	cbFn(arg0)
			194	+	}
			195	+	UserDestroyVarRef = purego.NewCallback(fcb)
			196	+	glib.SaveCallback(UserDestroyVarPtr, UserDestroyVarRef)
			197	+	}
			198	+	}
			199	+
			200	+	xMapListModelSetMapFunc(x.GoPointer(), MapFuncVarRef, UserDataVar, UserDestroyVarRef)
141			201
142		}	202		}
143			203

M v4/gtk/gtkmediafile.go +6 -6


@@ -351,15 +351,15 @@ func (x *MediaFile) SetFile(FileVar gio.File) {
351			351
352		}	352		}
353			353
354	-	var xMediaFileSetFilename func(uintptr, string)	354	+	var xMediaFileSetFilename func(uintptr, uintptr)
355			355
356		// Sets the `GtkMediaFile` to play the given file.	356		// Sets the `GtkMediaFile` to play the given file.
357		//	357		//
358		// This is a utility function that converts the given @filename	358		// This is a utility function that converts the given @filename
359		// to a `GFile` and calls [method@Gtk.MediaFile.set_file].	359		// to a `GFile` and calls [method@Gtk.MediaFile.set_file].
360	-	func (x *MediaFile) SetFilename(FilenameVar string) {	360	+	func (x MediaFile) SetFilename(FilenameVar string) {
361			361
362	-	xMediaFileSetFilename(x.GoPointer(), FilenameVar)	362	+	xMediaFileSetFilename(x.GoPointer(), core.NullableStringToPtr(FilenameVar))
363			363
364		}	364		}
365			365

@@ -377,15 +377,15 @@ func (x MediaFile) SetInputStream(StreamVar gio.InputStream) {
377			377
378		}	378		}
379			379
380	-	var xMediaFileSetResource func(uintptr, string)	380	+	var xMediaFileSetResource func(uintptr, uintptr)
381			381
382		// Sets the `GtkMediaFile` to play the given resource.	382		// Sets the `GtkMediaFile` to play the given resource.
383		//	383		//
384		// This is a utility function that converts the given @resource_path	384		// This is a utility function that converts the given @resource_path
385		// to a `GFile` and calls [method@Gtk.MediaFile.set_file].	385		// to a `GFile` and calls [method@Gtk.MediaFile.set_file].
386	-	func (x *MediaFile) SetResource(ResourcePathVar string) {	386	+	func (x MediaFile) SetResource(ResourcePathVar string) {
387			387
388	-	xMediaFileSetResource(x.GoPointer(), ResourcePathVar)	388	+	xMediaFileSetResource(x.GoPointer(), core.NullableStringToPtr(ResourcePathVar))
389			389
390		}	390		}
391			391

M v4/gtk/gtkmenubutton.go +33 -3


@@ -347,7 +347,37 @@ var xMenuButtonSetCreatePopupFunc func(uintptr, uintptr, uintptr, uintptr)
347		// @menu_button. Instead, this can be done manually in @func.	347		// @menu_button. Instead, this can be done manually in @func.
348		func (x MenuButton) SetCreatePopupFunc(FuncVar MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {	348		func (x MenuButton) SetCreatePopupFunc(FuncVar MenuButtonCreatePopupFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
349			349
350	-	xMenuButtonSetCreatePopupFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), UserDataVar, glib.NewCallbackNullable(DestroyNotifyVar))	350	+	var FuncVarRef uintptr
			351	+	if FuncVar != nil {
			352	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			353	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			354	+	FuncVarRef = cbRefPtr
			355	+	} else {
			356	+	fcb := func(arg0 uintptr, arg1 uintptr) {
			357	+	cbFn := *FuncVar
			358	+	cbFn(arg0, arg1)
			359	+	}
			360	+	FuncVarRef = purego.NewCallback(fcb)
			361	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			362	+	}
			363	+	}
			364	+
			365	+	var DestroyNotifyVarRef uintptr
			366	+	if DestroyNotifyVar != nil {
			367	+	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
			368	+	if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
			369	+	DestroyNotifyVarRef = cbRefPtr
			370	+	} else {
			371	+	fcb := func(arg0 uintptr) {
			372	+	cbFn := *DestroyNotifyVar
			373	+	cbFn(arg0)
			374	+	}
			375	+	DestroyNotifyVarRef = purego.NewCallback(fcb)
			376	+	glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
			377	+	}
			378	+	}
			379	+
			380	+	xMenuButtonSetCreatePopupFunc(x.GoPointer(), FuncVarRef, UserDataVar, DestroyNotifyVarRef)
351			381
352		}	382		}
353			383

@@ -547,7 +577,7 @@ func (x *MenuButton) GetPropertyHasFrame() bool {
547		func (x *MenuButton) SetPropertyIconName(value string) {	577		func (x *MenuButton) SetPropertyIconName(value string) {
548		var v gobject.Value	578		var v gobject.Value
549		v.Init(gobject.TypeStringVal)	579		v.Init(gobject.TypeStringVal)
550	-	v.SetString(value)	580	+	v.SetString(&value)
551		x.SetProperty("icon-name", &v)	581		x.SetProperty("icon-name", &v)
552		}	582		}
553			583

@@ -564,7 +594,7 @@ func (x *MenuButton) GetPropertyIconName() string {
564		func (x *MenuButton) SetPropertyLabel(value string) {	594		func (x *MenuButton) SetPropertyLabel(value string) {
565		var v gobject.Value	595		var v gobject.Value
566		v.Init(gobject.TypeStringVal)	596		v.Init(gobject.TypeStringVal)
567	-	v.SetString(value)	597	+	v.SetString(&value)
568		x.SetProperty("label", &v)	598		x.SetProperty("label", &v)
569		}	599		}
570			600

M v4/gtk/gtkmessagedialog.go +11 -11


@@ -137,7 +137,7 @@ func MessageDialogNewFromInternalPtr(ptr uintptr) *MessageDialog {
137		return cls	137		return cls
138		}	138		}
139			139
140	-	var xNewMessageDialog func(uintptr, DialogFlags, MessageType, ButtonsType, string, ...interface{}) uintptr	140	+	var xNewMessageDialog func(uintptr, DialogFlags, MessageType, ButtonsType, uintptr, ...interface{}) uintptr
141			141
142		// Creates a new message dialog.	142		// Creates a new message dialog.
143		//	143		//

@@ -145,10 +145,10 @@ var xNewMessageDialog func(uintptr, DialogFlags, MessageType, ButtonsType, strin
145		// When the user clicks a button a “response” signal is emitted with	145		// When the user clicks a button a “response” signal is emitted with
146		// response IDs from [enum@Gtk.ResponseType]. See [class@Gtk.Dialog]	146		// response IDs from [enum@Gtk.ResponseType]. See [class@Gtk.Dialog]
147		// for more details.	147		// for more details.
148	-	func NewMessageDialog(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) MessageDialog {	148	+	func NewMessageDialog(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) *MessageDialog {
149		var cls *MessageDialog	149		var cls *MessageDialog
150			150
151	-	cret := xNewMessageDialog(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, MessageFormatVar, varArgs...)	151	+	cret := xNewMessageDialog(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, core.NullableStringToPtr(MessageFormatVar), varArgs...)
152			152
153		if cret == 0 {	153		if cret == 0 {
154		return nil	154		return nil

@@ -159,7 +159,7 @@ func NewMessageDialog(ParentVar *Window, FlagsVar DialogFlags, TypeVar MessageTy
159		return cls	159		return cls
160		}	160		}
161			161
162	-	var xNewMessageDialogWithMarkup func(uintptr, DialogFlags, MessageType, ButtonsType, string, ...interface{}) uintptr	162	+	var xNewMessageDialogWithMarkup func(uintptr, DialogFlags, MessageType, ButtonsType, uintptr, ...interface{}) uintptr
163			163
164		// Creates a new message dialog.	164		// Creates a new message dialog.
165		//	165		//

@@ -193,10 +193,10 @@ var xNewMessageDialogWithMarkup func(uintptr, DialogFlags, MessageType, ButtonsT
193		// markup);	193		// markup);
194		//	194		//
195		// ```	195		// ```
196	-	func NewMessageDialogWithMarkup(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) MessageDialog {	196	+	func NewMessageDialogWithMarkup(ParentVar Window, FlagsVar DialogFlags, TypeVar MessageType, ButtonsVar ButtonsType, MessageFormatVar string, varArgs ...interface{}) *MessageDialog {
197		var cls *MessageDialog	197		var cls *MessageDialog
198			198
199	-	cret := xNewMessageDialogWithMarkup(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, MessageFormatVar, varArgs...)	199	+	cret := xNewMessageDialogWithMarkup(ParentVar.GoPointer(), FlagsVar, TypeVar, ButtonsVar, core.NullableStringToPtr(MessageFormatVar), varArgs...)
200			200
201		if cret == 0 {	201		if cret == 0 {
202		return nil	202		return nil

@@ -234,12 +234,12 @@ func (x *MessageDialog) FormatSecondaryMarkup(MessageFormatVar string, varArgs .
234			234
235		}	235		}
236			236
237	-	var xMessageDialogFormatSecondaryText func(uintptr, string, ...interface{})	237	+	var xMessageDialogFormatSecondaryText func(uintptr, uintptr, ...interface{})
238			238
239		// Sets the secondary text of the message dialog.	239		// Sets the secondary text of the message dialog.
240	-	func (x *MessageDialog) FormatSecondaryText(MessageFormatVar string, varArgs ...interface{}) {	240	+	func (x MessageDialog) FormatSecondaryText(MessageFormatVar string, varArgs ...interface{}) {
241			241
242	-	xMessageDialogFormatSecondaryText(x.GoPointer(), MessageFormatVar, varArgs...)	242	+	xMessageDialogFormatSecondaryText(x.GoPointer(), core.NullableStringToPtr(MessageFormatVar), varArgs...)
243			243
244		}	244		}
245			245

@@ -290,7 +290,7 @@ func (c *MessageDialog) SetGoPointer(ptr uintptr) {
290		func (x *MessageDialog) SetPropertySecondaryText(value string) {	290		func (x *MessageDialog) SetPropertySecondaryText(value string) {
291		var v gobject.Value	291		var v gobject.Value
292		v.Init(gobject.TypeStringVal)	292		v.Init(gobject.TypeStringVal)
293	-	v.SetString(value)	293	+	v.SetString(&value)
294		x.SetProperty("secondary-text", &v)	294		x.SetProperty("secondary-text", &v)
295		}	295		}
296			296

@@ -330,7 +330,7 @@ func (x *MessageDialog) GetPropertySecondaryUseMarkup() bool {
330		func (x *MessageDialog) SetPropertyText(value string) {	330		func (x *MessageDialog) SetPropertyText(value string) {
331		var v gobject.Value	331		var v gobject.Value
332		v.Init(gobject.TypeStringVal)	332		v.Init(gobject.TypeStringVal)
333	-	v.SetString(value)	333	+	v.SetString(&value)
334		x.SetProperty("text", &v)	334		x.SetProperty("text", &v)
335		}	335		}
336			336

M v4/gtk/gtknativedialog.go +1 -1


@@ -398,7 +398,7 @@ func (x *NativeDialog) GetPropertyModal() bool {
398		func (x *NativeDialog) SetPropertyTitle(value string) {	398		func (x *NativeDialog) SetPropertyTitle(value string) {
399		var v gobject.Value	399		var v gobject.Value
400		v.Init(gobject.TypeStringVal)	400		v.Init(gobject.TypeStringVal)
401	-	v.SetString(value)	401	+	v.SetString(&value)
402		x.SetProperty("title", &v)	402		x.SetProperty("title", &v)
403		}	403		}
404			404

M v4/gtk/gtknotebook.go +6 -6


@@ -572,16 +572,16 @@ func (x *Notebook) SetCurrentPage(PageNumVar int) {
572			572
573		}	573		}
574			574
575	-	var xNotebookSetGroupName func(uintptr, string)	575	+	var xNotebookSetGroupName func(uintptr, uintptr)
576			576
577		// Sets a group name for @notebook.	577		// Sets a group name for @notebook.
578		//	578		//
579		// Notebooks with the same name will be able to exchange tabs	579		// Notebooks with the same name will be able to exchange tabs
580		// via drag and drop. A notebook with a %NULL group name will	580		// via drag and drop. A notebook with a %NULL group name will
581		// not be able to exchange tabs with any other notebook.	581		// not be able to exchange tabs with any other notebook.
582	-	func (x *Notebook) SetGroupName(GroupNameVar string) {	582	+	func (x Notebook) SetGroupName(GroupNameVar string) {
583			583
584	-	xNotebookSetGroupName(x.GoPointer(), GroupNameVar)	584	+	xNotebookSetGroupName(x.GoPointer(), core.NullableStringToPtr(GroupNameVar))
585			585
586		}	586		}
587			587

@@ -763,7 +763,7 @@ func (x *Notebook) GetPropertyEnablePopup() bool {
763		func (x *Notebook) SetPropertyGroupName(value string) {	763		func (x *Notebook) SetPropertyGroupName(value string) {
764		var v gobject.Value	764		var v gobject.Value
765		v.Init(gobject.TypeStringVal)	765		v.Init(gobject.TypeStringVal)
766	-	v.SetString(value)	766	+	v.SetString(&value)
767		x.SetProperty("group-name", &v)	767		x.SetProperty("group-name", &v)
768		}	768		}
769			769

@@ -1418,7 +1418,7 @@ func (x *NotebookPage) GetPropertyDetachable() bool {
1418		func (x *NotebookPage) SetPropertyMenuLabel(value string) {	1418		func (x *NotebookPage) SetPropertyMenuLabel(value string) {
1419		var v gobject.Value	1419		var v gobject.Value
1420		v.Init(gobject.TypeStringVal)	1420		v.Init(gobject.TypeStringVal)
1421	-	v.SetString(value)	1421	+	v.SetString(&value)
1422		x.SetProperty("menu-label", &v)	1422		x.SetProperty("menu-label", &v)
1423		}	1423		}
1424			1424

@@ -1503,7 +1503,7 @@ func (x *NotebookPage) GetPropertyTabFill() bool {
1503		func (x *NotebookPage) SetPropertyTabLabel(value string) {	1503		func (x *NotebookPage) SetPropertyTabLabel(value string) {
1504		var v gobject.Value	1504		var v gobject.Value
1505		v.Init(gobject.TypeStringVal)	1505		v.Init(gobject.TypeStringVal)
1506	-	v.SetString(value)	1506	+	v.SetString(&value)
1507		x.SetProperty("tab-label", &v)	1507		x.SetProperty("tab-label", &v)
1508		}	1508		}
1509			1509

M v4/gtk/gtkpagesetup.go +9 -9


@@ -129,18 +129,18 @@ func NewPageSetupFromGvariant(VariantVar glib.Variant) PageSetup {
129		return cls	129		return cls
130		}	130		}
131			131
132	-	var xNewPageSetupFromKeyFile func(glib.KeyFile, string, *glib.Error) uintptr	132	+	var xNewPageSetupFromKeyFile func(glib.KeyFile, uintptr, *glib.Error) uintptr
133			133
134		// Reads the page setup from the group @group_name in the key file	134		// Reads the page setup from the group @group_name in the key file
135		// @key_file.	135		// @key_file.
136		//	136		//
137		// Returns a new `GtkPageSetup` object with the restored	137		// Returns a new `GtkPageSetup` object with the restored
138		// page setup, or %NULL if an error occurred.	138		// page setup, or %NULL if an error occurred.
139	-	func NewPageSetupFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (PageSetup, error) {	139	+	func NewPageSetupFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (*PageSetup, error) {
140		var cls *PageSetup	140		var cls *PageSetup
141		var cerr *glib.Error	141		var cerr *glib.Error
142			142
143	-	cret := xNewPageSetupFromKeyFile(KeyFileVar, GroupNameVar, &cerr)	143	+	cret := xNewPageSetupFromKeyFile(KeyFileVar, core.NullableStringToPtr(GroupNameVar), &cerr)
144			144
145		if cret == 0 {	145		if cret == 0 {
146		return nil, cerr	146		return nil, cerr

@@ -292,14 +292,14 @@ func (x *PageSetup) LoadFile(FileNameVar string) (bool, error) {
292			292
293		}	293		}
294			294
295	-	var xPageSetupLoadKeyFile func(uintptr, glib.KeyFile, string, *glib.Error) bool	295	+	var xPageSetupLoadKeyFile func(uintptr, glib.KeyFile, uintptr, *glib.Error) bool
296			296
297		// Reads the page setup from the group @group_name in the key file	297		// Reads the page setup from the group @group_name in the key file
298		// @key_file.	298		// @key_file.
299	-	func (x PageSetup) LoadKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (bool, error) {	299	+	func (x PageSetup) LoadKeyFile(KeyFileVar glib.KeyFile, GroupNameVar *string) (bool, error) {
300		var cerr *glib.Error	300		var cerr *glib.Error
301			301
302	-	cret := xPageSetupLoadKeyFile(x.GoPointer(), KeyFileVar, GroupNameVar, &cerr)	302	+	cret := xPageSetupLoadKeyFile(x.GoPointer(), KeyFileVar, core.NullableStringToPtr(GroupNameVar), &cerr)
303		if cerr == nil {	303		if cerr == nil {
304		return cret, nil	304		return cret, nil
305		}	305		}

@@ -397,12 +397,12 @@ func (x PageSetup) ToGvariant() glib.Variant {
397		return cret	397		return cret
398		}	398		}
399			399
400	-	var xPageSetupToKeyFile func(uintptr, *glib.KeyFile, string)	400	+	var xPageSetupToKeyFile func(uintptr, *glib.KeyFile, uintptr)
401			401
402		// This function adds the page setup from @setup to @key_file.	402		// This function adds the page setup from @setup to @key_file.
403	-	func (x PageSetup) ToKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) {	403	+	func (x PageSetup) ToKeyFile(KeyFileVar glib.KeyFile, GroupNameVar *string) {
404			404
405	-	xPageSetupToKeyFile(x.GoPointer(), KeyFileVar, GroupNameVar)	405	+	xPageSetupToKeyFile(x.GoPointer(), KeyFileVar, core.NullableStringToPtr(GroupNameVar))
406			406
407		}	407		}
408			408

M v4/gtk/gtkpagesetupunixdialog.go +3 -3


@@ -44,13 +44,13 @@ func PageSetupUnixDialogNewFromInternalPtr(ptr uintptr) *PageSetupUnixDialog {
44		return cls	44		return cls
45		}	45		}
46			46
47	-	var xNewPageSetupUnixDialog func(string, uintptr) uintptr	47	+	var xNewPageSetupUnixDialog func(uintptr, uintptr) uintptr
48			48
49		// Creates a new page setup dialog.	49		// Creates a new page setup dialog.
50	-	func NewPageSetupUnixDialog(TitleVar string, ParentVar Window) PageSetupUnixDialog {	50	+	func NewPageSetupUnixDialog(TitleVar string, ParentVar Window) *PageSetupUnixDialog {
51		var cls *PageSetupUnixDialog	51		var cls *PageSetupUnixDialog
52			52
53	-	cret := xNewPageSetupUnixDialog(TitleVar, ParentVar.GoPointer())	53	+	cret := xNewPageSetupUnixDialog(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer())
54			54
55		if cret == 0 {	55		if cret == 0 {
56		return nil	56		return nil

M v4/gtk/gtkpapersize.go +6 -6


@@ -36,7 +36,7 @@ func (x *PaperSize) GoPointer() uintptr {
36		return uintptr(unsafe.Pointer(x))	36		return uintptr(unsafe.Pointer(x))
37		}	37		}
38			38
39	-	var xNewPaperSize func(string) *PaperSize	39	+	var xNewPaperSize func(uintptr) *PaperSize
40			40
41		// Creates a new `GtkPaperSize` object by parsing a	41		// Creates a new `GtkPaperSize` object by parsing a
42		// [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf)	42		// [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf)

@@ -44,9 +44,9 @@ var xNewPaperSize func(string) *PaperSize
44		//	44		//
45		// If @name is %NULL, the default paper size is returned,	45		// If @name is %NULL, the default paper size is returned,
46		// see [func@Gtk.PaperSize.get_default].	46		// see [func@Gtk.PaperSize.get_default].
47	-	func NewPaperSize(NameVar string) *PaperSize {	47	+	func NewPaperSize(NameVar string) PaperSize {
48			48
49	-	cret := xNewPaperSize(NameVar)	49	+	cret := xNewPaperSize(core.NullableStringToPtr(NameVar))
50		return cret	50		return cret
51		}	51		}
52			52

@@ -86,14 +86,14 @@ func NewPaperSizeFromIpp(IppNameVar string, WidthVar float64, HeightVar float64)
86		return cret	86		return cret
87		}	87		}
88			88
89	-	var xNewPaperSizeFromKeyFile func(glib.KeyFile, string, glib.Error) PaperSize	89	+	var xNewPaperSizeFromKeyFile func(glib.KeyFile, uintptr, glib.Error) PaperSize
90			90
91		// Reads a paper size from the group @group_name in the key file	91		// Reads a paper size from the group @group_name in the key file
92		// @key_file.	92		// @key_file.
93	-	func NewPaperSizeFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (PaperSize, error) {	93	+	func NewPaperSizeFromKeyFile(KeyFileVar glib.KeyFile, GroupNameVar string) (*PaperSize, error) {
94		var cerr *glib.Error	94		var cerr *glib.Error
95			95
96	-	cret := xNewPaperSizeFromKeyFile(KeyFileVar, GroupNameVar, &cerr)	96	+	cret := xNewPaperSizeFromKeyFile(KeyFileVar, core.NullableStringToPtr(GroupNameVar), &cerr)
97		if cerr == nil {	97		if cerr == nil {
98		return cret, nil	98		return cret, nil
99		}	99		}

M v4/gtk/gtkpasswordentry.go +1 -1


@@ -176,7 +176,7 @@ func (x *PasswordEntry) GetPropertyActivatesDefault() bool {
176		func (x *PasswordEntry) SetPropertyPlaceholderText(value string) {	176		func (x *PasswordEntry) SetPropertyPlaceholderText(value string) {
177		var v gobject.Value	177		var v gobject.Value
178		v.Init(gobject.TypeStringVal)	178		v.Init(gobject.TypeStringVal)
179	-	v.SetString(value)	179	+	v.SetString(&value)
180		x.SetProperty("placeholder-text", &v)	180		x.SetProperty("placeholder-text", &v)
181		}	181		}
182			182

M v4/gtk/gtkpicture.go +16 -16


@@ -132,16 +132,16 @@ func NewPictureForFile(FileVar gio.File) *Picture {
132		return cls	132		return cls
133		}	133		}
134			134
135	-	var xNewPictureForFilename func(string) uintptr	135	+	var xNewPictureForFilename func(uintptr) uintptr
136			136
137		// Creates a new `GtkPicture` displaying the file @filename.	137		// Creates a new `GtkPicture` displaying the file @filename.
138		//	138		//
139		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].	139		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].
140		// See that function for details.	140		// See that function for details.
141	-	func NewPictureForFilename(FilenameVar string) *Picture {	141	+	func NewPictureForFilename(FilenameVar string) Picture {
142		var cls *Picture	142		var cls *Picture
143			143
144	-	cret := xNewPictureForFilename(FilenameVar)	144	+	cret := xNewPictureForFilename(core.NullableStringToPtr(FilenameVar))
145			145
146		if cret == 0 {	146		if cret == 0 {
147		return nil	147		return nil

@@ -194,16 +194,16 @@ func NewPictureForPixbuf(PixbufVar gdkpixbuf.Pixbuf) Picture {
194		return cls	194		return cls
195		}	195		}
196			196
197	-	var xNewPictureForResource func(string) uintptr	197	+	var xNewPictureForResource func(uintptr) uintptr
198			198
199		// Creates a new `GtkPicture` displaying the resource at @resource_path.	199		// Creates a new `GtkPicture` displaying the resource at @resource_path.
200		//	200		//
201		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].	201		// This is a utility function that calls [ctor@Gtk.Picture.new_for_file].
202		// See that function for details.	202		// See that function for details.
203	-	func NewPictureForResource(ResourcePathVar string) *Picture {	203	+	func NewPictureForResource(ResourcePathVar string) Picture {
204		var cls *Picture	204		var cls *Picture
205			205
206	-	cret := xNewPictureForResource(ResourcePathVar)	206	+	cret := xNewPictureForResource(core.NullableStringToPtr(ResourcePathVar))
207			207
208		if cret == 0 {	208		if cret == 0 {
209		return nil	209		return nil

@@ -291,7 +291,7 @@ func (x Picture) GetPaintable() gdk.PaintableBase {
291		return cls	291		return cls
292		}	292		}
293			293
294	-	var xPictureSetAlternativeText func(uintptr, string)	294	+	var xPictureSetAlternativeText func(uintptr, uintptr)
295			295
296		// Sets an alternative textual description for the picture contents.	296		// Sets an alternative textual description for the picture contents.
297		//	297		//

@@ -300,9 +300,9 @@ var xPictureSetAlternativeText func(uintptr, string)
300		// This text will be made available to accessibility tools.	300		// This text will be made available to accessibility tools.
301		//	301		//
302		// If the picture cannot be described textually, set this property to %NULL.	302		// If the picture cannot be described textually, set this property to %NULL.
303	-	func (x *Picture) SetAlternativeText(AlternativeTextVar string) {	303	+	func (x Picture) SetAlternativeText(AlternativeTextVar string) {
304			304
305	-	xPictureSetAlternativeText(x.GoPointer(), AlternativeTextVar)	305	+	xPictureSetAlternativeText(x.GoPointer(), core.NullableStringToPtr(AlternativeTextVar))
306			306
307		}	307		}
308			308

@@ -353,7 +353,7 @@ func (x *Picture) SetFile(FileVar gio.File) {
353			353
354		}	354		}
355			355
356	-	var xPictureSetFilename func(uintptr, string)	356	+	var xPictureSetFilename func(uintptr, uintptr)
357			357
358		// Makes @self load and display the given @filename.	358		// Makes @self load and display the given @filename.
359		//	359		//

@@ -365,9 +365,9 @@ var xPictureSetFilename func(uintptr, string)
365		// Use a proper image loading framework such as libglycin, which can	365		// Use a proper image loading framework such as libglycin, which can
366		// load many image formats into a `GdkTexture`, and then use	366		// load many image formats into a `GdkTexture`, and then use
367		// [method@Gtk.Image.set_from_paintable].	367		// [method@Gtk.Image.set_from_paintable].
368	-	func (x *Picture) SetFilename(FilenameVar string) {	368	+	func (x Picture) SetFilename(FilenameVar string) {
369			369
370	-	xPictureSetFilename(x.GoPointer(), FilenameVar)	370	+	xPictureSetFilename(x.GoPointer(), core.NullableStringToPtr(FilenameVar))
371			371
372		}	372		}
373			373

@@ -413,15 +413,15 @@ func (x Picture) SetPixbuf(PixbufVar gdkpixbuf.Pixbuf) {
413			413
414		}	414		}
415			415
416	-	var xPictureSetResource func(uintptr, string)	416	+	var xPictureSetResource func(uintptr, uintptr)
417			417
418		// Makes @self load and display the resource at the given	418		// Makes @self load and display the resource at the given
419		// @resource_path.	419		// @resource_path.
420		//	420		//
421		// This is a utility function that calls [method@Gtk.Picture.set_file].	421		// This is a utility function that calls [method@Gtk.Picture.set_file].
422	-	func (x *Picture) SetResource(ResourcePathVar string) {	422	+	func (x Picture) SetResource(ResourcePathVar string) {
423			423
424	-	xPictureSetResource(x.GoPointer(), ResourcePathVar)	424	+	xPictureSetResource(x.GoPointer(), core.NullableStringToPtr(ResourcePathVar))
425			425
426		}	426		}
427			427

@@ -441,7 +441,7 @@ func (c *Picture) SetGoPointer(ptr uintptr) {
441		func (x *Picture) SetPropertyAlternativeText(value string) {	441		func (x *Picture) SetPropertyAlternativeText(value string) {
442		var v gobject.Value	442		var v gobject.Value
443		v.Init(gobject.TypeStringVal)	443		v.Init(gobject.TypeStringVal)
444	-	v.SetString(value)	444	+	v.SetString(&value)
445		x.SetProperty("alternative-text", &v)	445		x.SetProperty("alternative-text", &v)
446		}	446		}
447			447

M v4/gtk/gtkpopovermenu.go +1 -1


@@ -291,7 +291,7 @@ func (c *PopoverMenu) SetGoPointer(ptr uintptr) {
291		func (x *PopoverMenu) SetPropertyVisibleSubmenu(value string) {	291		func (x *PopoverMenu) SetPropertyVisibleSubmenu(value string) {
292		var v gobject.Value	292		var v gobject.Value
293		v.Init(gobject.TypeStringVal)	293		v.Init(gobject.TypeStringVal)
294	-	v.SetString(value)	294	+	v.SetString(&value)
295		x.SetProperty("visible-submenu", &v)	295		x.SetProperty("visible-submenu", &v)
296		}	296		}
297			297

M v4/gtk/gtkprintdialog.go +50 -5


@@ -226,7 +226,22 @@ var xPrintDialogPrint func(uintptr, uintptr, *PrintSetup, uintptr, uintptr, uint
226		// The @callback will be called when the printing is done.	226		// The @callback will be called when the printing is done.
227		func (x PrintDialog) Print(ParentVar Window, SetupVar PrintSetup, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	227		func (x PrintDialog) Print(ParentVar Window, SetupVar PrintSetup, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
228			228
229	-	xPrintDialogPrint(x.GoPointer(), ParentVar.GoPointer(), SetupVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	229	+	var CallbackVarRef uintptr
			230	+	if CallbackVar != nil {
			231	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			232	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			233	+	CallbackVarRef = cbRefPtr
			234	+	} else {
			235	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			236	+	cbFn := *CallbackVar
			237	+	cbFn(arg0, arg1, arg2)
			238	+	}
			239	+	CallbackVarRef = purego.NewCallback(fcb)
			240	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			241	+	}
			242	+	}
			243	+
			244	+	xPrintDialogPrint(x.GoPointer(), ParentVar.GoPointer(), SetupVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
230			245
231		}	246		}
232			247

@@ -238,7 +253,22 @@ var xPrintDialogPrintFile func(uintptr, uintptr, *PrintSetup, uintptr, uintptr,
238		// Otherwise, it will attempt to print directly, without user interaction.	253		// Otherwise, it will attempt to print directly, without user interaction.
239		func (x PrintDialog) PrintFile(ParentVar Window, SetupVar PrintSetup, FileVar gio.File, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	254		func (x PrintDialog) PrintFile(ParentVar Window, SetupVar PrintSetup, FileVar gio.File, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
240			255
241	-	xPrintDialogPrintFile(x.GoPointer(), ParentVar.GoPointer(), SetupVar, FileVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	256	+	var CallbackVarRef uintptr
			257	+	if CallbackVar != nil {
			258	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			259	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			260	+	CallbackVarRef = cbRefPtr
			261	+	} else {
			262	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			263	+	cbFn := *CallbackVar
			264	+	cbFn(arg0, arg1, arg2)
			265	+	}
			266	+	CallbackVarRef = purego.NewCallback(fcb)
			267	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			268	+	}
			269	+	}
			270	+
			271	+	xPrintDialogPrintFile(x.GoPointer(), ParentVar.GoPointer(), SetupVar, FileVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
242			272
243		}	273		}
244			274

@@ -359,7 +389,22 @@ var xPrintDialogSetup func(uintptr, uintptr, uintptr, uintptr, uintptr)
359		// to do the printing without further user interaction.	389		// to do the printing without further user interaction.
360		func (x PrintDialog) Setup(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {	390		func (x PrintDialog) Setup(ParentVar Window, CancellableVar gio.Cancellable, CallbackVar gio.AsyncReadyCallback, UserDataVar uintptr) {
361			391
362	-	xPrintDialogSetup(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	392	+	var CallbackVarRef uintptr
			393	+	if CallbackVar != nil {
			394	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			395	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			396	+	CallbackVarRef = cbRefPtr
			397	+	} else {
			398	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			399	+	cbFn := *CallbackVar
			400	+	cbFn(arg0, arg1, arg2)
			401	+	}
			402	+	CallbackVarRef = purego.NewCallback(fcb)
			403	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			404	+	}
			405	+	}
			406	+
			407	+	xPrintDialogSetup(x.GoPointer(), ParentVar.GoPointer(), CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
363			408
364		}	409		}
365			410

@@ -401,7 +446,7 @@ func (c *PrintDialog) SetGoPointer(ptr uintptr) {
401		func (x *PrintDialog) SetPropertyAcceptLabel(value string) {	446		func (x *PrintDialog) SetPropertyAcceptLabel(value string) {
402		var v gobject.Value	447		var v gobject.Value
403		v.Init(gobject.TypeStringVal)	448		v.Init(gobject.TypeStringVal)
404	-	v.SetString(value)	449	+	v.SetString(&value)
405		x.SetProperty("accept-label", &v)	450		x.SetProperty("accept-label", &v)
406		}	451		}
407			452

@@ -437,7 +482,7 @@ func (x *PrintDialog) GetPropertyModal() bool {
437		func (x *PrintDialog) SetPropertyTitle(value string) {	482		func (x *PrintDialog) SetPropertyTitle(value string) {
438		var v gobject.Value	483		var v gobject.Value
439		v.Init(gobject.TypeStringVal)	484		v.Init(gobject.TypeStringVal)
440	-	v.SetString(value)	485	+	v.SetString(&value)
441		x.SetProperty("title", &v)	486		x.SetProperty("title", &v)
442		}	487		}
443			488

M v4/gtk/gtkprinter.go +32 -2


@@ -75,7 +75,37 @@ var xEnumeratePrinters func(uintptr, uintptr, uintptr, bool)
75		// If @func returns true, the enumeration is stopped.	75		// If @func returns true, the enumeration is stopped.
76		func EnumeratePrinters(FuncVar PrinterFunc, DataVar uintptr, DestroyVar glib.DestroyNotify, WaitVar bool) {	76		func EnumeratePrinters(FuncVar PrinterFunc, DataVar uintptr, DestroyVar glib.DestroyNotify, WaitVar bool) {
77			77
78	-	xEnumeratePrinters(glib.NewCallback(FuncVar), DataVar, glib.NewCallback(DestroyVar), WaitVar)	78	+	var FuncVarRef uintptr
			79	+	if FuncVar != nil {
			80	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			81	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			82	+	FuncVarRef = cbRefPtr
			83	+	} else {
			84	+	fcb := func(arg0 uintptr, arg1 uintptr) bool {
			85	+	cbFn := *FuncVar
			86	+	return cbFn(arg0, arg1)
			87	+	}
			88	+	FuncVarRef = purego.NewCallback(fcb)
			89	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			90	+	}
			91	+	}
			92	+
			93	+	var DestroyVarRef uintptr
			94	+	if DestroyVar != nil {
			95	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			96	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			97	+	DestroyVarRef = cbRefPtr
			98	+	} else {
			99	+	fcb := func(arg0 uintptr) {
			100	+	cbFn := *DestroyVar
			101	+	cbFn(arg0)
			102	+	}
			103	+	DestroyVarRef = purego.NewCallback(fcb)
			104	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			105	+	}
			106	+	}
			107	+
			108	+	xEnumeratePrinters(FuncVarRef, DataVar, DestroyVarRef, WaitVar)
79			109
80		}	110		}
81			111

@@ -463,7 +493,7 @@ func (x *Printer) GetPropertyLocation() string {
463		func (x *Printer) SetPropertyName(value string) {	493		func (x *Printer) SetPropertyName(value string) {
464		var v gobject.Value	494		var v gobject.Value
465		v.Init(gobject.TypeStringVal)	495		v.Init(gobject.TypeStringVal)
466	-	v.SetString(value)	496	+	v.SetString(&value)
467		x.SetProperty("name", &v)	497		x.SetProperty("name", &v)
468		}	498		}
469			499

M v4/gtk/gtkprintjob.go +32 -2


@@ -232,7 +232,37 @@ var xPrintJobSend func(uintptr, uintptr, uintptr, uintptr)
232		// Sends the print job off to the printer.	232		// Sends the print job off to the printer.
233		func (x PrintJob) Send(CallbackVar PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {	233		func (x PrintJob) Send(CallbackVar PrintJobCompleteFunc, UserDataVar uintptr, DnotifyVar *glib.DestroyNotify) {
234			234
235	-	xPrintJobSend(x.GoPointer(), glib.NewCallback(CallbackVar), UserDataVar, glib.NewCallback(DnotifyVar))	235	+	var CallbackVarRef uintptr
			236	+	if CallbackVar != nil {
			237	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			238	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			239	+	CallbackVarRef = cbRefPtr
			240	+	} else {
			241	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 *glib.Error) {
			242	+	cbFn := *CallbackVar
			243	+	cbFn(arg0, arg1, arg2)
			244	+	}
			245	+	CallbackVarRef = purego.NewCallback(fcb)
			246	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			247	+	}
			248	+	}
			249	+
			250	+	var DnotifyVarRef uintptr
			251	+	if DnotifyVar != nil {
			252	+	DnotifyVarPtr := uintptr(unsafe.Pointer(DnotifyVar))
			253	+	if cbRefPtr, ok := glib.GetCallback(DnotifyVarPtr); ok {
			254	+	DnotifyVarRef = cbRefPtr
			255	+	} else {
			256	+	fcb := func(arg0 uintptr) {
			257	+	cbFn := *DnotifyVar
			258	+	cbFn(arg0)
			259	+	}
			260	+	DnotifyVarRef = purego.NewCallback(fcb)
			261	+	glib.SaveCallback(DnotifyVarPtr, DnotifyVarRef)
			262	+	}
			263	+	}
			264	+
			265	+	xPrintJobSend(x.GoPointer(), CallbackVarRef, UserDataVar, DnotifyVarRef)
236			266
237		}	267		}
238			268

@@ -404,7 +434,7 @@ func (c *PrintJob) SetGoPointer(ptr uintptr) {
404		func (x *PrintJob) SetPropertyTitle(value string) {	434		func (x *PrintJob) SetPropertyTitle(value string) {
405		var v gobject.Value	435		var v gobject.Value
406		v.Init(gobject.TypeStringVal)	436		v.Init(gobject.TypeStringVal)
407	-	v.SetString(value)	437	+	v.SetString(&value)
408		x.SetProperty("title", &v)	438		x.SetProperty("title", &v)
409		}	439		}
410			440

M v4/gtk/gtkprintoperation.go +22 -7

 // @done_cb from a signal handler for the ::response signal of the dialog.
 func PrintRunPageSetupDialogAsync(ParentVar *Window, PageSetupVar *PageSetup, SettingsVar *PrintSettings, DoneCbVar *PageSetupDoneFunc, DataVar uintptr) {
-	xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), glib.NewCallback(DoneCbVar), DataVar)
+	var DoneCbVarRef uintptr
+	if DoneCbVar != nil {
+		DoneCbVarPtr := uintptr(unsafe.Pointer(DoneCbVar))
+		if cbRefPtr, ok := glib.GetCallback(DoneCbVarPtr); ok {
+			DoneCbVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 uintptr, arg1 uintptr) {
+				cbFn := *DoneCbVar
+				cbFn(arg0, arg1)
+			}
+			DoneCbVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(DoneCbVarPtr, DoneCbVarRef)
+		}
+	}
+	xPrintRunPageSetupDialogAsync(ParentVar.GoPointer(), PageSetupVar.GoPointer(), SettingsVar.GoPointer(), DoneCbVarRef, DataVar)
 }
 }
-var xPrintOperationSetCustomTabLabel func(uintptr, string)
+var xPrintOperationSetCustomTabLabel func(uintptr, uintptr)
 // Sets the label for the tab holding custom widgets.
-func (x *PrintOperation) SetCustomTabLabel(LabelVar string) {
+func (x *PrintOperation) SetCustomTabLabel(LabelVar *string) {
-	xPrintOperationSetCustomTabLabel(x.GoPointer(), LabelVar)
+	xPrintOperationSetCustomTabLabel(x.GoPointer(), core.NullableStringToPtr(LabelVar))
 }
 func (x *PrintOperation) SetPropertyCustomTabLabel(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("custom-tab-label", &v)
 }
 func (x *PrintOperation) SetPropertyExportFilename(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("export-filename", &v)
 }
 func (x *PrintOperation) SetPropertyJobName(value string) {
 	var v gobject.Value
 	v.Init(gobject.TypeStringVal)
-	v.SetString(value)
+	v.SetString(&value)
 	x.SetProperty("job-name", &v)
 }

M v4/gtk/gtkprintsettings.go +28 -13

 	return cls
 }
-var xNewPrintSettingsFromKeyFile func(*glib.KeyFile, string, **glib.Error) uintptr
+var xNewPrintSettingsFromKeyFile func(*glib.KeyFile, uintptr, **glib.Error) uintptr
 // Reads the print settings from the group @group_name in @key_file.
 //
 // Returns a new `GtkPrintSettings` object with the restored settings,
 // or %NULL if an error occurred. If the file could not be loaded then
 // error is set to either `GFileError` or `GKeyFileError`.
-func NewPrintSettingsFromKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar string) (*PrintSettings, error) {
+func NewPrintSettingsFromKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar *string) (*PrintSettings, error) {
 	var cls *PrintSettings
 	var cerr *glib.Error
-	cret := xNewPrintSettingsFromKeyFile(KeyFileVar, GroupNameVar, &cerr)
+	cret := xNewPrintSettingsFromKeyFile(KeyFileVar, core.NullableStringToPtr(GroupNameVar), &cerr)
 	if cret == 0 {
 		return nil, cerr
 // Calls @func for each key-value pair of @settings.
 func (x *PrintSettings) Foreach(FuncVar *PrintSettingsFunc, UserDataVar uintptr) {
-	xPrintSettingsForeach(x.GoPointer(), glib.NewCallback(FuncVar), UserDataVar)
+	var FuncVarRef uintptr
+	if FuncVar != nil {
+		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
+		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
+			FuncVarRef = cbRefPtr
+		} else {
+			fcb := func(arg0 string, arg1 string, arg2 uintptr) {
+				cbFn := *FuncVar
+				cbFn(arg0, arg1, arg2)
+			}
+			FuncVarRef = purego.NewCallback(fcb)
+			glib.SaveCallback(FuncVarPtr, FuncVarRef)
+		}
+	}
+	xPrintSettingsForeach(x.GoPointer(), FuncVarRef, UserDataVar)
 }
 }
-var xPrintSettingsLoadKeyFile func(uintptr, *glib.KeyFile, string, **glib.Error) bool
+var xPrintSettingsLoadKeyFile func(uintptr, *glib.KeyFile, uintptr, **glib.Error) bool
 // Reads the print settings from the group @group_name in @key_file.
 //
 // If the file could not be loaded then error is set to either a
 // `GFileError` or `GKeyFileError`.
-func (x *PrintSettings) LoadKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar string) (bool, error) {
+func (x *PrintSettings) LoadKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar *string) (bool, error) {
 	var cerr *glib.Error
-	cret := xPrintSettingsLoadKeyFile(x.GoPointer(), KeyFileVar, GroupNameVar, &cerr)
+	cret := xPrintSettingsLoadKeyFile(x.GoPointer(), KeyFileVar, core.NullableStringToPtr(GroupNameVar), &cerr)
 	if cerr == nil {
 		return cret, nil
 	}
 }
-var xPrintSettingsSet func(uintptr, string, string)
+var xPrintSettingsSet func(uintptr, string, uintptr)
 // Associates @value with @key.
-func (x *PrintSettings) Set(KeyVar string, ValueVar string) {
+func (x *PrintSettings) Set(KeyVar string, ValueVar *string) {
-	xPrintSettingsSet(x.GoPointer(), KeyVar, ValueVar)
+	xPrintSettingsSet(x.GoPointer(), KeyVar, core.NullableStringToPtr(ValueVar))
 }
 	return cret
 }
-var xPrintSettingsToKeyFile func(uintptr, *glib.KeyFile, string)
+var xPrintSettingsToKeyFile func(uintptr, *glib.KeyFile, uintptr)
 // This function adds the print settings from @settings to @key_file.
-func (x *PrintSettings) ToKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar string) {
+func (x *PrintSettings) ToKeyFile(KeyFileVar *glib.KeyFile, GroupNameVar *string) {
-	xPrintSettingsToKeyFile(x.GoPointer(), KeyFileVar, GroupNameVar)
+	xPrintSettingsToKeyFile(x.GoPointer(), KeyFileVar, core.NullableStringToPtr(GroupNameVar))
 }

M v4/gtk/gtkprintunixdialog.go +3 -3


@@ -89,13 +89,13 @@ func PrintUnixDialogNewFromInternalPtr(ptr uintptr) *PrintUnixDialog {
89		return cls	89		return cls
90		}	90		}
91			91
92	-	var xNewPrintUnixDialog func(string, uintptr) uintptr	92	+	var xNewPrintUnixDialog func(uintptr, uintptr) uintptr
93			93
94		// Creates a new `GtkPrintUnixDialog`.	94		// Creates a new `GtkPrintUnixDialog`.
95	-	func NewPrintUnixDialog(TitleVar string, ParentVar Window) PrintUnixDialog {	95	+	func NewPrintUnixDialog(TitleVar string, ParentVar Window) *PrintUnixDialog {
96		var cls *PrintUnixDialog	96		var cls *PrintUnixDialog
97			97
98	-	cret := xNewPrintUnixDialog(TitleVar, ParentVar.GoPointer())	98	+	cret := xNewPrintUnixDialog(core.NullableStringToPtr(TitleVar), ParentVar.GoPointer())
99			99
100		if cret == 0 {	100		if cret == 0 {
101		return nil	101		return nil

M v4/gtk/gtkprogressbar.go +4 -4


@@ -239,7 +239,7 @@ func (x *ProgressBar) SetShowText(ShowTextVar bool) {
239			239
240		}	240		}
241			241
242	-	var xProgressBarSetText func(uintptr, string)	242	+	var xProgressBarSetText func(uintptr, uintptr)
243			243
244		// Causes the given @text to appear next to the progress bar.	244		// Causes the given @text to appear next to the progress bar.
245		//	245		//

@@ -252,9 +252,9 @@ var xProgressBarSetText func(uintptr, string)
252		// percentage. If @text is the empty string, the progress bar will still	252		// percentage. If @text is the empty string, the progress bar will still
253		// be styled and sized suitably for containing text, as long as	253		// be styled and sized suitably for containing text, as long as
254		// [property@Gtk.ProgressBar:show-text] is %TRUE.	254		// [property@Gtk.ProgressBar:show-text] is %TRUE.
255	-	func (x *ProgressBar) SetText(TextVar string) {	255	+	func (x ProgressBar) SetText(TextVar string) {
256			256
257	-	xProgressBarSetText(x.GoPointer(), TextVar)	257	+	xProgressBarSetText(x.GoPointer(), core.NullableStringToPtr(TextVar))
258			258
259		}	259		}
260			260

@@ -360,7 +360,7 @@ func (x *ProgressBar) GetPropertyShowText() bool {
360		func (x *ProgressBar) SetPropertyText(value string) {	360		func (x *ProgressBar) SetPropertyText(value string) {
361		var v gobject.Value	361		var v gobject.Value
362		v.Init(gobject.TypeStringVal)	362		v.Init(gobject.TypeStringVal)
363	-	v.SetString(value)	363	+	v.SetString(&value)
364		x.SetProperty("text", &v)	364		x.SetProperty("text", &v)
365		}	365		}
366			366

M v4/gtk/gtkrecentmanager.go +7 -7


@@ -53,17 +53,17 @@ func (x *RecentInfo) GoPointer() uintptr {
53		return uintptr(unsafe.Pointer(x))	53		return uintptr(unsafe.Pointer(x))
54		}	54		}
55			55
56	-	var xRecentInfoCreateAppInfo func(uintptr, string, **glib.Error) uintptr	56	+	var xRecentInfoCreateAppInfo func(uintptr, uintptr, **glib.Error) uintptr
57			57
58		// Creates a `GAppInfo` for the specified `GtkRecentInfo`	58		// Creates a `GAppInfo` for the specified `GtkRecentInfo`
59		//	59		//
60		// In case of error, @error will be set either with a	60		// In case of error, @error will be set either with a
61		// %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR	61		// %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
62	-	func (x RecentInfo) CreateAppInfo(AppNameVar string) (gio.AppInfoBase, error) {	62	+	func (x RecentInfo) CreateAppInfo(AppNameVar string) (*gio.AppInfoBase, error) {
63		var cls *gio.AppInfoBase	63		var cls *gio.AppInfoBase
64		var cerr *glib.Error	64		var cerr *glib.Error
65			65
66	-	cret := xRecentInfoCreateAppInfo(x.GoPointer(), AppNameVar, &cerr)	66	+	cret := xRecentInfoCreateAppInfo(x.GoPointer(), core.NullableStringToPtr(AppNameVar), &cerr)
67			67
68		if cret == 0 {	68		if cret == 0 {
69		return nil, cerr	69		return nil, cerr

@@ -690,16 +690,16 @@ func (x RecentManager) LookupItem(UriVar string) (RecentInfo, error) {
690			690
691		}	691		}
692			692
693	-	var xRecentManagerMoveItem func(uintptr, string, string, **glib.Error) bool	693	+	var xRecentManagerMoveItem func(uintptr, string, uintptr, **glib.Error) bool
694			694
695		// Changes the location of a recently used resource from @uri to @new_uri.	695		// Changes the location of a recently used resource from @uri to @new_uri.
696		//	696		//
697		// Please note that this function will not affect the resource pointed	697		// Please note that this function will not affect the resource pointed
698		// by the URIs, but only the URI used in the recently used resources list.	698		// by the URIs, but only the URI used in the recently used resources list.
699	-	func (x *RecentManager) MoveItem(UriVar string, NewUriVar string) (bool, error) {	699	+	func (x RecentManager) MoveItem(UriVar string, NewUriVar string) (bool, error) {
700		var cerr *glib.Error	700		var cerr *glib.Error
701			701
702	-	cret := xRecentManagerMoveItem(x.GoPointer(), UriVar, NewUriVar, &cerr)	702	+	cret := xRecentManagerMoveItem(x.GoPointer(), UriVar, core.NullableStringToPtr(NewUriVar), &cerr)
703		if cerr == nil {	703		if cerr == nil {
704		return cret, nil	704		return cret, nil
705		}	705		}

@@ -753,7 +753,7 @@ func (c *RecentManager) SetGoPointer(ptr uintptr) {
753		func (x *RecentManager) SetPropertyFilename(value string) {	753		func (x *RecentManager) SetPropertyFilename(value string) {
754		var v gobject.Value	754		var v gobject.Value
755		v.Init(gobject.TypeStringVal)	755		v.Init(gobject.TypeStringVal)
756	-	v.SetString(value)	756	+	v.SetString(&value)
757		x.SetProperty("filename", &v)	757		x.SetProperty("filename", &v)
758		}	758		}
759			759

M v4/gtk/gtkscale.go +34 -4


@@ -211,7 +211,7 @@ func NewScaleWithRange(OrientationVar Orientation, MinVar float64, MaxVar float6
211		return cls	211		return cls
212		}	212		}
213			213
214	-	var xScaleAddMark func(uintptr, float64, PositionType, string)	214	+	var xScaleAddMark func(uintptr, float64, PositionType, uintptr)
215			215
216		// Adds a mark at @value.	216		// Adds a mark at @value.
217		//	217		//

@@ -222,9 +222,9 @@ var xScaleAddMark func(uintptr, float64, PositionType, string)
222		// If @markup is not %NULL, text is shown next to the tick mark.	222		// If @markup is not %NULL, text is shown next to the tick mark.
223		//	223		//
224		// To remove marks from a scale, use [method@Gtk.Scale.clear_marks].	224		// To remove marks from a scale, use [method@Gtk.Scale.clear_marks].
225	-	func (x *Scale) AddMark(ValueVar float64, PositionVar PositionType, MarkupVar string) {	225	+	func (x Scale) AddMark(ValueVar float64, PositionVar PositionType, MarkupVar string) {
226			226
227	-	xScaleAddMark(x.GoPointer(), ValueVar, PositionVar, MarkupVar)	227	+	xScaleAddMark(x.GoPointer(), ValueVar, PositionVar, core.NullableStringToPtr(MarkupVar))
228			228
229		}	229		}
230			230

@@ -352,7 +352,37 @@ var xScaleSetFormatValueFunc func(uintptr, uintptr, uintptr, uintptr)
352		// [property@Gtk.Scale:digits] property.	352		// [property@Gtk.Scale:digits] property.
353		func (x Scale) SetFormatValueFunc(FuncVar ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {	353		func (x Scale) SetFormatValueFunc(FuncVar ScaleFormatValueFunc, UserDataVar uintptr, DestroyNotifyVar *glib.DestroyNotify) {
354			354
355	-	xScaleSetFormatValueFunc(x.GoPointer(), glib.NewCallbackNullable(FuncVar), UserDataVar, glib.NewCallbackNullable(DestroyNotifyVar))	355	+	var FuncVarRef uintptr
			356	+	if FuncVar != nil {
			357	+	FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
			358	+	if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			359	+	FuncVarRef = cbRefPtr
			360	+	} else {
			361	+	fcb := func(arg0 uintptr, arg1 float64, arg2 uintptr) string {
			362	+	cbFn := *FuncVar
			363	+	return cbFn(arg0, arg1, arg2)
			364	+	}
			365	+	FuncVarRef = purego.NewCallback(fcb)
			366	+	glib.SaveCallback(FuncVarPtr, FuncVarRef)
			367	+	}
			368	+	}
			369	+
			370	+	var DestroyNotifyVarRef uintptr
			371	+	if DestroyNotifyVar != nil {
			372	+	DestroyNotifyVarPtr := uintptr(unsafe.Pointer(DestroyNotifyVar))
			373	+	if cbRefPtr, ok := glib.GetCallback(DestroyNotifyVarPtr); ok {
			374	+	DestroyNotifyVarRef = cbRefPtr
			375	+	} else {
			376	+	fcb := func(arg0 uintptr) {
			377	+	cbFn := *DestroyNotifyVar
			378	+	cbFn(arg0)
			379	+	}
			380	+	DestroyNotifyVarRef = purego.NewCallback(fcb)
			381	+	glib.SaveCallback(DestroyNotifyVarPtr, DestroyNotifyVarRef)
			382	+	}
			383	+	}
			384	+
			385	+	xScaleSetFormatValueFunc(x.GoPointer(), FuncVarRef, UserDataVar, DestroyNotifyVarRef)
356			386
357		}	387		}
358			388

M v4/gtk/gtksearchentry.go +4 -4


@@ -198,12 +198,12 @@ func (x SearchEntry) SetKeyCaptureWidget(WidgetVar Widget) {
198			198
199		}	199		}
200			200
201	-	var xSearchEntrySetPlaceholderText func(uintptr, string)	201	+	var xSearchEntrySetPlaceholderText func(uintptr, uintptr)
202			202
203		// Sets the placeholder text associated with @entry.	203		// Sets the placeholder text associated with @entry.
204	-	func (x *SearchEntry) SetPlaceholderText(TextVar string) {	204	+	func (x SearchEntry) SetPlaceholderText(TextVar string) {
205			205
206	-	xSearchEntrySetPlaceholderText(x.GoPointer(), TextVar)	206	+	xSearchEntrySetPlaceholderText(x.GoPointer(), core.NullableStringToPtr(TextVar))
207			207
208		}	208		}
209			209

@@ -251,7 +251,7 @@ func (x *SearchEntry) GetPropertyActivatesDefault() bool {
251		func (x *SearchEntry) SetPropertyPlaceholderText(value string) {	251		func (x *SearchEntry) SetPropertyPlaceholderText(value string) {
252		var v gobject.Value	252		var v gobject.Value
253		v.Init(gobject.TypeStringVal)	253		v.Init(gobject.TypeStringVal)
254	-	v.SetString(value)	254	+	v.SetString(&value)
255		x.SetProperty("placeholder-text", &v)	255		x.SetProperty("placeholder-text", &v)
256		}	256		}
257			257

M v4/gtk/gtksettings.go +14 -14


@@ -252,7 +252,7 @@ func (x *Settings) GetPropertyGtkCursorBlinkTimeout() int {
252		func (x *Settings) SetPropertyGtkCursorThemeName(value string) {	252		func (x *Settings) SetPropertyGtkCursorThemeName(value string) {
253		var v gobject.Value	253		var v gobject.Value
254		v.Init(gobject.TypeStringVal)	254		v.Init(gobject.TypeStringVal)
255	-	v.SetString(value)	255	+	v.SetString(&value)
256		x.SetProperty("gtk-cursor-theme-name", &v)	256		x.SetProperty("gtk-cursor-theme-name", &v)
257		}	257		}
258			258

@@ -311,7 +311,7 @@ func (x *Settings) GetPropertyGtkCursorThemeSize() int {
311		func (x *Settings) SetPropertyGtkDecorationLayout(value string) {	311		func (x *Settings) SetPropertyGtkDecorationLayout(value string) {
312		var v gobject.Value	312		var v gobject.Value
313		v.Init(gobject.TypeStringVal)	313		v.Init(gobject.TypeStringVal)
314	-	v.SetString(value)	314	+	v.SetString(&value)
315		x.SetProperty("gtk-decoration-layout", &v)	315		x.SetProperty("gtk-decoration-layout", &v)
316		}	316		}
317			317

@@ -613,7 +613,7 @@ func (x *Settings) GetPropertyGtkErrorBell() bool {
613		func (x *Settings) SetPropertyGtkFontName(value string) {	613		func (x *Settings) SetPropertyGtkFontName(value string) {
614		var v gobject.Value	614		var v gobject.Value
615		v.Init(gobject.TypeStringVal)	615		v.Init(gobject.TypeStringVal)
616	-	v.SetString(value)	616	+	v.SetString(&value)
617		x.SetProperty("gtk-font-name", &v)	617		x.SetProperty("gtk-font-name", &v)
618		}	618		}
619			619

@@ -675,7 +675,7 @@ func (x *Settings) GetPropertyGtkHintFontMetrics() bool {
675		func (x *Settings) SetPropertyGtkIconThemeName(value string) {	675		func (x *Settings) SetPropertyGtkIconThemeName(value string) {
676		var v gobject.Value	676		var v gobject.Value
677		v.Init(gobject.TypeStringVal)	677		v.Init(gobject.TypeStringVal)
678	-	v.SetString(value)	678	+	v.SetString(&value)
679		x.SetProperty("gtk-icon-theme-name", &v)	679		x.SetProperty("gtk-icon-theme-name", &v)
680		}	680		}
681			681

@@ -702,7 +702,7 @@ func (x *Settings) GetPropertyGtkIconThemeName() string {
702		func (x *Settings) SetPropertyGtkImModule(value string) {	702		func (x *Settings) SetPropertyGtkImModule(value string) {
703		var v gobject.Value	703		var v gobject.Value
704		v.Init(gobject.TypeStringVal)	704		v.Init(gobject.TypeStringVal)
705	-	v.SetString(value)	705	+	v.SetString(&value)
706		x.SetProperty("gtk-im-module", &v)	706		x.SetProperty("gtk-im-module", &v)
707		}	707		}
708			708

@@ -851,7 +851,7 @@ func (x *Settings) GetPropertyGtkPrimaryButtonWarpsSlider() bool {
851		func (x *Settings) SetPropertyGtkPrintBackends(value string) {	851		func (x *Settings) SetPropertyGtkPrintBackends(value string) {
852		var v gobject.Value	852		var v gobject.Value
853		v.Init(gobject.TypeStringVal)	853		v.Init(gobject.TypeStringVal)
854	-	v.SetString(value)	854	+	v.SetString(&value)
855		x.SetProperty("gtk-print-backends", &v)	855		x.SetProperty("gtk-print-backends", &v)
856		}	856		}
857			857

@@ -881,7 +881,7 @@ func (x *Settings) GetPropertyGtkPrintBackends() string {
881		func (x *Settings) SetPropertyGtkPrintPreviewCommand(value string) {	881		func (x *Settings) SetPropertyGtkPrintPreviewCommand(value string) {
882		var v gobject.Value	882		var v gobject.Value
883		v.Init(gobject.TypeStringVal)	883		v.Init(gobject.TypeStringVal)
884	-	v.SetString(value)	884	+	v.SetString(&value)
885		x.SetProperty("gtk-print-preview-command", &v)	885		x.SetProperty("gtk-print-preview-command", &v)
886		}	886		}
887			887

@@ -1037,7 +1037,7 @@ func (x *Settings) GetPropertyGtkShowStatusShapes() bool {
1037		func (x *Settings) SetPropertyGtkSoundThemeName(value string) {	1037		func (x *Settings) SetPropertyGtkSoundThemeName(value string) {
1038		var v gobject.Value	1038		var v gobject.Value
1039		v.Init(gobject.TypeStringVal)	1039		v.Init(gobject.TypeStringVal)
1040	-	v.SetString(value)	1040	+	v.SetString(&value)
1041		x.SetProperty("gtk-sound-theme-name", &v)	1041		x.SetProperty("gtk-sound-theme-name", &v)
1042		}	1042		}
1043			1043

@@ -1082,7 +1082,7 @@ func (x *Settings) GetPropertyGtkSplitCursor() bool {
1082		func (x *Settings) SetPropertyGtkThemeName(value string) {	1082		func (x *Settings) SetPropertyGtkThemeName(value string) {
1083		var v gobject.Value	1083		var v gobject.Value
1084		v.Init(gobject.TypeStringVal)	1084		v.Init(gobject.TypeStringVal)
1085	-	v.SetString(value)	1085	+	v.SetString(&value)
1086		x.SetProperty("gtk-theme-name", &v)	1086		x.SetProperty("gtk-theme-name", &v)
1087		}	1087		}
1088			1088

@@ -1106,7 +1106,7 @@ func (x *Settings) GetPropertyGtkThemeName() string {
1106		func (x *Settings) SetPropertyGtkTitlebarDoubleClick(value string) {	1106		func (x *Settings) SetPropertyGtkTitlebarDoubleClick(value string) {
1107		var v gobject.Value	1107		var v gobject.Value
1108		v.Init(gobject.TypeStringVal)	1108		v.Init(gobject.TypeStringVal)
1109	-	v.SetString(value)	1109	+	v.SetString(&value)
1110		x.SetProperty("gtk-titlebar-double-click", &v)	1110		x.SetProperty("gtk-titlebar-double-click", &v)
1111		}	1111		}
1112			1112

@@ -1131,7 +1131,7 @@ func (x *Settings) GetPropertyGtkTitlebarDoubleClick() string {
1131		func (x *Settings) SetPropertyGtkTitlebarMiddleClick(value string) {	1131		func (x *Settings) SetPropertyGtkTitlebarMiddleClick(value string) {
1132		var v gobject.Value	1132		var v gobject.Value
1133		v.Init(gobject.TypeStringVal)	1133		v.Init(gobject.TypeStringVal)
1134	-	v.SetString(value)	1134	+	v.SetString(&value)
1135		x.SetProperty("gtk-titlebar-middle-click", &v)	1135		x.SetProperty("gtk-titlebar-middle-click", &v)
1136		}	1136		}
1137			1137

@@ -1156,7 +1156,7 @@ func (x *Settings) GetPropertyGtkTitlebarMiddleClick() string {
1156		func (x *Settings) SetPropertyGtkTitlebarRightClick(value string) {	1156		func (x *Settings) SetPropertyGtkTitlebarRightClick(value string) {
1157		var v gobject.Value	1157		var v gobject.Value
1158		v.Init(gobject.TypeStringVal)	1158		v.Init(gobject.TypeStringVal)
1159	-	v.SetString(value)	1159	+	v.SetString(&value)
1160		x.SetProperty("gtk-titlebar-right-click", &v)	1160		x.SetProperty("gtk-titlebar-right-click", &v)
1161		}	1161		}
1162			1162

@@ -1243,7 +1243,7 @@ func (x *Settings) GetPropertyGtkXftHinting() int {
1243		func (x *Settings) SetPropertyGtkXftHintstyle(value string) {	1243		func (x *Settings) SetPropertyGtkXftHintstyle(value string) {
1244		var v gobject.Value	1244		var v gobject.Value
1245		v.Init(gobject.TypeStringVal)	1245		v.Init(gobject.TypeStringVal)
1246	-	v.SetString(value)	1246	+	v.SetString(&value)
1247		x.SetProperty("gtk-xft-hintstyle", &v)	1247		x.SetProperty("gtk-xft-hintstyle", &v)
1248		}	1248		}
1249			1249

@@ -1268,7 +1268,7 @@ func (x *Settings) GetPropertyGtkXftHintstyle() string {
1268		func (x *Settings) SetPropertyGtkXftRgba(value string) {	1268		func (x *Settings) SetPropertyGtkXftRgba(value string) {
1269		var v gobject.Value	1269		var v gobject.Value
1270		v.Init(gobject.TypeStringVal)	1270		v.Init(gobject.TypeStringVal)
1271	-	v.SetString(value)	1271	+	v.SetString(&value)
1272		x.SetProperty("gtk-xft-rgba", &v)	1272		x.SetProperty("gtk-xft-rgba", &v)
1273		}	1273		}
1274			1274

M v4/gtk/gtkshortcut.go +3 -3


@@ -70,14 +70,14 @@ func NewShortcut(TriggerVar ShortcutTrigger, ActionVar ShortcutAction) *Shortc
70		return cls	70		return cls
71		}	71		}
72			72
73	-	var xNewShortcutWithArguments func(uintptr, uintptr, string, ...interface{}) uintptr	73	+	var xNewShortcutWithArguments func(uintptr, uintptr, uintptr, ...interface{}) uintptr
74			74
75		// Creates a new `GtkShortcut` that is triggered by @trigger and then activates	75		// Creates a new `GtkShortcut` that is triggered by @trigger and then activates
76		// @action with arguments given by @format_string.	76		// @action with arguments given by @format_string.
77	-	func NewShortcutWithArguments(TriggerVar ShortcutTrigger, ActionVar ShortcutAction, FormatStringVar string, varArgs ...interface{}) *Shortcut {	77	+	func NewShortcutWithArguments(TriggerVar ShortcutTrigger, ActionVar ShortcutAction, FormatStringVar string, varArgs ...interface{}) Shortcut {
78		var cls *Shortcut	78		var cls *Shortcut
79			79
80	-	cret := xNewShortcutWithArguments(TriggerVar.GoPointer(), ActionVar.GoPointer(), FormatStringVar, varArgs...)	80	+	cret := xNewShortcutWithArguments(TriggerVar.GoPointer(), ActionVar.GoPointer(), core.NullableStringToPtr(FormatStringVar), varArgs...)
81			81
82		if cret == 0 {	82		if cret == 0 {
83		return nil	83		return nil

M v4/gtk/gtkshortcutaction.go +33 -3


@@ -164,7 +164,37 @@ var xNewCallbackAction func(uintptr, uintptr, uintptr) uintptr
164		func NewCallbackAction(CallbackVar ShortcutFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAction {	164		func NewCallbackAction(CallbackVar ShortcutFunc, DataVar uintptr, DestroyVar glib.DestroyNotify) *CallbackAction {
165		var cls *CallbackAction	165		var cls *CallbackAction
166			166
167	-	cret := xNewCallbackAction(glib.NewCallback(CallbackVar), DataVar, glib.NewCallback(DestroyVar))	167	+	var CallbackVarRef uintptr
			168	+	if CallbackVar != nil {
			169	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			170	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			171	+	CallbackVarRef = cbRefPtr
			172	+	} else {
			173	+	fcb := func(arg0 uintptr, arg1 *glib.Variant, arg2 uintptr) bool {
			174	+	cbFn := *CallbackVar
			175	+	return cbFn(arg0, arg1, arg2)
			176	+	}
			177	+	CallbackVarRef = purego.NewCallback(fcb)
			178	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			179	+	}
			180	+	}
			181	+
			182	+	var DestroyVarRef uintptr
			183	+	if DestroyVar != nil {
			184	+	DestroyVarPtr := uintptr(unsafe.Pointer(DestroyVar))
			185	+	if cbRefPtr, ok := glib.GetCallback(DestroyVarPtr); ok {
			186	+	DestroyVarRef = cbRefPtr
			187	+	} else {
			188	+	fcb := func(arg0 uintptr) {
			189	+	cbFn := *DestroyVar
			190	+	cbFn(arg0)
			191	+	}
			192	+	DestroyVarRef = purego.NewCallback(fcb)
			193	+	glib.SaveCallback(DestroyVarPtr, DestroyVarRef)
			194	+	}
			195	+	}
			196	+
			197	+	cret := xNewCallbackAction(CallbackVarRef, DataVar, DestroyVarRef)
168			198
169		if cret == 0 {	199		if cret == 0 {
170		return nil	200		return nil

@@ -303,7 +333,7 @@ func (c *NamedAction) SetGoPointer(ptr uintptr) {
303		func (x *NamedAction) SetPropertyActionName(value string) {	333		func (x *NamedAction) SetPropertyActionName(value string) {
304		var v gobject.Value	334		var v gobject.Value
305		v.Init(gobject.TypeStringVal)	335		v.Init(gobject.TypeStringVal)
306	-	v.SetString(value)	336	+	v.SetString(&value)
307		x.SetProperty("action-name", &v)	337		x.SetProperty("action-name", &v)
308		}	338		}
309			339

@@ -548,7 +578,7 @@ func (c *SignalAction) SetGoPointer(ptr uintptr) {
548		func (x *SignalAction) SetPropertySignalName(value string) {	578		func (x *SignalAction) SetPropertySignalName(value string) {
549		var v gobject.Value	579		var v gobject.Value
550		v.Init(gobject.TypeStringVal)	580		v.Init(gobject.TypeStringVal)
551	-	v.SetString(value)	581	+	v.SetString(&value)
552		x.SetProperty("signal-name", &v)	582		x.SetProperty("signal-name", &v)
553		}	583		}
554			584

M v4/gtk/gtkshortcutlabel.go +2 -2


@@ -110,7 +110,7 @@ func (c *ShortcutLabel) SetGoPointer(ptr uintptr) {
110		func (x *ShortcutLabel) SetPropertyAccelerator(value string) {	110		func (x *ShortcutLabel) SetPropertyAccelerator(value string) {
111		var v gobject.Value	111		var v gobject.Value
112		v.Init(gobject.TypeStringVal)	112		v.Init(gobject.TypeStringVal)
113	-	v.SetString(value)	113	+	v.SetString(&value)
114		x.SetProperty("accelerator", &v)	114		x.SetProperty("accelerator", &v)
115		}	115		}
116			116

@@ -130,7 +130,7 @@ func (x *ShortcutLabel) GetPropertyAccelerator() string {
130		func (x *ShortcutLabel) SetPropertyDisabledText(value string) {	130		func (x *ShortcutLabel) SetPropertyDisabledText(value string) {
131		var v gobject.Value	131		var v gobject.Value
132		v.Init(gobject.TypeStringVal)	132		v.Init(gobject.TypeStringVal)
133	-	v.SetString(value)	133	+	v.SetString(&value)
134		x.SetProperty("disabled-text", &v)	134		x.SetProperty("disabled-text", &v)
135		}	135		}
136			136

M v4/gtk/gtkshortcutsgroup.go +2 -2


@@ -90,7 +90,7 @@ func (x *ShortcutsGroup) GetPropertyHeight() uint {
90		func (x *ShortcutsGroup) SetPropertyTitle(value string) {	90		func (x *ShortcutsGroup) SetPropertyTitle(value string) {
91		var v gobject.Value	91		var v gobject.Value
92		v.Init(gobject.TypeStringVal)	92		v.Init(gobject.TypeStringVal)
93	-	v.SetString(value)	93	+	v.SetString(&value)
94		x.SetProperty("title", &v)	94		x.SetProperty("title", &v)
95		}	95		}
96			96

@@ -112,7 +112,7 @@ func (x *ShortcutsGroup) GetPropertyTitle() string {
112		func (x *ShortcutsGroup) SetPropertyView(value string) {	112		func (x *ShortcutsGroup) SetPropertyView(value string) {
113		var v gobject.Value	113		var v gobject.Value
114		v.Init(gobject.TypeStringVal)	114		v.Init(gobject.TypeStringVal)
115	-	v.SetString(value)	115	+	v.SetString(&value)
116		x.SetProperty("view", &v)	116		x.SetProperty("view", &v)
117		}	117		}
118			118

M v4/gtk/gtkshortcutssection.go +3 -3


@@ -126,7 +126,7 @@ func (x *ShortcutsSection) GetPropertyMaxHeight() uint {
126		func (x *ShortcutsSection) SetPropertySectionName(value string) {	126		func (x *ShortcutsSection) SetPropertySectionName(value string) {
127		var v gobject.Value	127		var v gobject.Value
128		v.Init(gobject.TypeStringVal)	128		v.Init(gobject.TypeStringVal)
129	-	v.SetString(value)	129	+	v.SetString(&value)
130		x.SetProperty("section-name", &v)	130		x.SetProperty("section-name", &v)
131		}	131		}
132			132

@@ -151,7 +151,7 @@ func (x *ShortcutsSection) GetPropertySectionName() string {
151		func (x *ShortcutsSection) SetPropertyTitle(value string) {	151		func (x *ShortcutsSection) SetPropertyTitle(value string) {
152		var v gobject.Value	152		var v gobject.Value
153		v.Init(gobject.TypeStringVal)	153		v.Init(gobject.TypeStringVal)
154	-	v.SetString(value)	154	+	v.SetString(&value)
155		x.SetProperty("title", &v)	155		x.SetProperty("title", &v)
156		}	156		}
157			157

@@ -178,7 +178,7 @@ func (x *ShortcutsSection) GetPropertyTitle() string {
178		func (x *ShortcutsSection) SetPropertyViewName(value string) {	178		func (x *ShortcutsSection) SetPropertyViewName(value string) {
179		var v gobject.Value	179		var v gobject.Value
180		v.Init(gobject.TypeStringVal)	180		v.Init(gobject.TypeStringVal)
181	-	v.SetString(value)	181	+	v.SetString(&value)
182		x.SetProperty("view-name", &v)	182		x.SetProperty("view-name", &v)
183		}	183		}
184			184

M v4/gtk/gtkshortcutsshortcut.go +4 -4


@@ -116,7 +116,7 @@ func (c *ShortcutsShortcut) SetGoPointer(ptr uintptr) {
116		func (x *ShortcutsShortcut) SetPropertyAccelerator(value string) {	116		func (x *ShortcutsShortcut) SetPropertyAccelerator(value string) {
117		var v gobject.Value	117		var v gobject.Value
118		v.Init(gobject.TypeStringVal)	118		v.Init(gobject.TypeStringVal)
119	-	v.SetString(value)	119	+	v.SetString(&value)
120		x.SetProperty("accelerator", &v)	120		x.SetProperty("accelerator", &v)
121		}	121		}
122			122

@@ -164,7 +164,7 @@ func (x *ShortcutsShortcut) GetPropertyAccelerator() string {
164		func (x *ShortcutsShortcut) SetPropertyActionName(value string) {	164		func (x *ShortcutsShortcut) SetPropertyActionName(value string) {
165		var v gobject.Value	165		var v gobject.Value
166		v.Init(gobject.TypeStringVal)	166		v.Init(gobject.TypeStringVal)
167	-	v.SetString(value)	167	+	v.SetString(&value)
168		x.SetProperty("action-name", &v)	168		x.SetProperty("action-name", &v)
169		}	169		}
170			170

@@ -207,7 +207,7 @@ func (x *ShortcutsShortcut) GetPropertyIconSet() bool {
207		func (x *ShortcutsShortcut) SetPropertySubtitle(value string) {	207		func (x *ShortcutsShortcut) SetPropertySubtitle(value string) {
208		var v gobject.Value	208		var v gobject.Value
209		v.Init(gobject.TypeStringVal)	209		v.Init(gobject.TypeStringVal)
210	-	v.SetString(value)	210	+	v.SetString(&value)
211		x.SetProperty("subtitle", &v)	211		x.SetProperty("subtitle", &v)
212		}	212		}
213			213

@@ -248,7 +248,7 @@ func (x *ShortcutsShortcut) GetPropertySubtitleSet() bool {
248		func (x *ShortcutsShortcut) SetPropertyTitle(value string) {	248		func (x *ShortcutsShortcut) SetPropertyTitle(value string) {
249		var v gobject.Value	249		var v gobject.Value
250		v.Init(gobject.TypeStringVal)	250		v.Init(gobject.TypeStringVal)
251	-	v.SetString(value)	251	+	v.SetString(&value)
252		x.SetProperty("title", &v)	252		x.SetProperty("title", &v)
253		}	253		}
254			254

M v4/gtk/gtkshortcutswindow.go +2 -2


@@ -136,7 +136,7 @@ func (c *ShortcutsWindow) SetGoPointer(ptr uintptr) {
136		func (x *ShortcutsWindow) SetPropertySectionName(value string) {	136		func (x *ShortcutsWindow) SetPropertySectionName(value string) {
137		var v gobject.Value	137		var v gobject.Value
138		v.Init(gobject.TypeStringVal)	138		v.Init(gobject.TypeStringVal)
139	-	v.SetString(value)	139	+	v.SetString(&value)
140		x.SetProperty("section-name", &v)	140		x.SetProperty("section-name", &v)
141		}	141		}
142			142

@@ -162,7 +162,7 @@ func (x *ShortcutsWindow) GetPropertySectionName() string {
162		func (x *ShortcutsWindow) SetPropertyViewName(value string) {	162		func (x *ShortcutsWindow) SetPropertyViewName(value string) {
163		var v gobject.Value	163		var v gobject.Value
164		v.Init(gobject.TypeStringVal)	164		v.Init(gobject.TypeStringVal)
165	-	v.SetString(value)	165	+	v.SetString(&value)
166		x.SetProperty("view-name", &v)	166		x.SetProperty("view-name", &v)
167		}	167		}
168			168

M v4/gtk/gtkshow.go +18 -1


@@ -2,6 +2,8 @@
2		package gtk	2		package gtk
3			3
4		import (	4		import (
			5	+	"unsafe"
			6	+
5		"github.com/jwijenbergh/purego"	7		"github.com/jwijenbergh/purego"
6		"github.com/jwijenbergh/puregotk/pkg/core"	8		"github.com/jwijenbergh/puregotk/pkg/core"
7		"github.com/jwijenbergh/puregotk/v4/gio"	9		"github.com/jwijenbergh/puregotk/v4/gio"

@@ -29,7 +31,22 @@ var xShowUriFull func(uintptr, string, uint32, uintptr, uintptr, uintptr)
29		// necessary for sandbox helpers to parent their dialogs properly.	31		// necessary for sandbox helpers to parent their dialogs properly.
30		func ShowUriFull(ParentVar Window, UriVar string, TimestampVar uint32, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {	32		func ShowUriFull(ParentVar Window, UriVar string, TimestampVar uint32, CancellableVar gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
31			33
32	-	xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)	34	+	var CallbackVarRef uintptr
			35	+	if CallbackVar != nil {
			36	+	CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
			37	+	if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			38	+	CallbackVarRef = cbRefPtr
			39	+	} else {
			40	+	fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
			41	+	cbFn := *CallbackVar
			42	+	cbFn(arg0, arg1, arg2)
			43	+	}
			44	+	CallbackVarRef = purego.NewCallback(fcb)
			45	+	glib.SaveCallback(CallbackVarPtr, CallbackVarRef)
			46	+	}
			47	+	}
			48	+
			49	+	xShowUriFull(ParentVar.GoPointer(), UriVar, TimestampVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)
33			50
34		}	51		}
35			52

M v4/gtk/gtkstack.go +10 -10


@@ -174,15 +174,15 @@ func (x Stack) AddChild(ChildVar Widget) *StackPage {
174		return cls	174		return cls
175		}	175		}
176			176
177	-	var xStackAddNamed func(uintptr, uintptr, string) uintptr	177	+	var xStackAddNamed func(uintptr, uintptr, uintptr) uintptr
178			178
179		// Adds a child to @stack.	179		// Adds a child to @stack.
180		//	180		//
181		// The child is identified by the @name.	181		// The child is identified by the @name.
182	-	func (x Stack) AddNamed(ChildVar Widget, NameVar string) *StackPage {	182	+	func (x Stack) AddNamed(ChildVar Widget, NameVar string) StackPage {
183		var cls *StackPage	183		var cls *StackPage
184			184
185	-	cret := xStackAddNamed(x.GoPointer(), ChildVar.GoPointer(), NameVar)	185	+	cret := xStackAddNamed(x.GoPointer(), ChildVar.GoPointer(), core.NullableStringToPtr(NameVar))
186			186
187		if cret == 0 {	187		if cret == 0 {
188		return nil	188		return nil

@@ -193,17 +193,17 @@ func (x Stack) AddNamed(ChildVar Widget, NameVar string) *StackPage {
193		return cls	193		return cls
194		}	194		}
195			195
196	-	var xStackAddTitled func(uintptr, uintptr, string, string) uintptr	196	+	var xStackAddTitled func(uintptr, uintptr, uintptr, string) uintptr
197			197
198		// Adds a child to @stack.	198		// Adds a child to @stack.
199		//	199		//
200		// The child is identified by the @name. The @title	200		// The child is identified by the @name. The @title
201		// will be used by `GtkStackSwitcher` to represent	201		// will be used by `GtkStackSwitcher` to represent
202		// @child in a tab bar, so it should be short.	202		// @child in a tab bar, so it should be short.
203	-	func (x Stack) AddTitled(ChildVar Widget, NameVar string, TitleVar string) *StackPage {	203	+	func (x Stack) AddTitled(ChildVar Widget, NameVar string, TitleVar string) StackPage {
204		var cls *StackPage	204		var cls *StackPage
205			205
206	-	cret := xStackAddTitled(x.GoPointer(), ChildVar.GoPointer(), NameVar, TitleVar)	206	+	cret := xStackAddTitled(x.GoPointer(), ChildVar.GoPointer(), core.NullableStringToPtr(NameVar), TitleVar)
207			207
208		if cret == 0 {	208		if cret == 0 {
209		return nil	209		return nil

@@ -573,7 +573,7 @@ func (x *Stack) GetPropertyVhomogeneous() bool {
573		func (x *Stack) SetPropertyVisibleChildName(value string) {	573		func (x *Stack) SetPropertyVisibleChildName(value string) {
574		var v gobject.Value	574		var v gobject.Value
575		v.Init(gobject.TypeStringVal)	575		v.Init(gobject.TypeStringVal)
576	-	v.SetString(value)	576	+	v.SetString(&value)
577		x.SetProperty("visible-child-name", &v)	577		x.SetProperty("visible-child-name", &v)
578		}	578		}
579			579

@@ -1024,7 +1024,7 @@ func (c *StackPage) SetGoPointer(ptr uintptr) {
1024		func (x *StackPage) SetPropertyIconName(value string) {	1024		func (x *StackPage) SetPropertyIconName(value string) {
1025		var v gobject.Value	1025		var v gobject.Value
1026		v.Init(gobject.TypeStringVal)	1026		v.Init(gobject.TypeStringVal)
1027	-	v.SetString(value)	1027	+	v.SetString(&value)
1028		x.SetProperty("icon-name", &v)	1028		x.SetProperty("icon-name", &v)
1029		}	1029		}
1030			1030

@@ -1041,7 +1041,7 @@ func (x *StackPage) GetPropertyIconName() string {
1041		func (x *StackPage) SetPropertyName(value string) {	1041		func (x *StackPage) SetPropertyName(value string) {
1042		var v gobject.Value	1042		var v gobject.Value
1043		v.Init(gobject.TypeStringVal)	1043		v.Init(gobject.TypeStringVal)
1044	-	v.SetString(value)	1044	+	v.SetString(&value)
1045		x.SetProperty("name", &v)	1045		x.SetProperty("name", &v)
1046		}	1046		}
1047			1047

@@ -1083,7 +1083,7 @@ func (x *StackPage) GetPropertyNeedsAttention() bool {
1083		func (x *StackPage) SetPropertyTitle(value string) {	1083		func (x *StackPage) SetPropertyTitle(value string) {
1084		var v gobject.Value	1084		var v gobject.Value
1085		v.Init(gobject.TypeStringVal)	1085		v.Init(gobject.TypeStringVal)
1086	-	v.SetString(value)	1086	+	v.SetString(&value)
1087		x.SetProperty("title", &v)	1087		x.SetProperty("title", &v)
1088		}	1088		}
1089			1089

M v4/gtk/gtkstringfilter.go +4 -4


@@ -165,12 +165,12 @@ func (x *StringFilter) SetMatchMode(ModeVar StringFilterMatchMode) {
165			165
166		}	166		}
167			167
168	-	var xStringFilterSetSearch func(uintptr, string)	168	+	var xStringFilterSetSearch func(uintptr, uintptr)
169			169
170		// Sets the string to search for.	170		// Sets the string to search for.
171	-	func (x *StringFilter) SetSearch(SearchVar string) {	171	+	func (x StringFilter) SetSearch(SearchVar string) {
172			172
173	-	xStringFilterSetSearch(x.GoPointer(), SearchVar)	173	+	xStringFilterSetSearch(x.GoPointer(), core.NullableStringToPtr(SearchVar))
174			174
175		}	175		}
176			176

@@ -207,7 +207,7 @@ func (x *StringFilter) GetPropertyIgnoreCase() bool {
207		func (x *StringFilter) SetPropertySearch(value string) {	207		func (x *StringFilter) SetPropertySearch(value string) {
208		var v gobject.Value	208		var v gobject.Value
209		v.Init(gobject.TypeStringVal)	209		v.Init(gobject.TypeStringVal)
210	-	v.SetString(value)	210	+	v.SetString(&value)
211		x.SetProperty("search", &v)	211		x.SetProperty("search", &v)
212		}	212		}
213			213

M v4/gtk/gtkswitch.go +2 -2


@@ -537,9 +537,9 @@ func (x Switch) GetActionTargetValue() glib.Variant {
537		// containing [class@ApplicationWindow] or its associated [class@Application],	537		// containing [class@ApplicationWindow] or its associated [class@Application],
538		// respectively. This is the same form used for actions in the [class@Gio.Menu]	538		// respectively. This is the same form used for actions in the [class@Gio.Menu]
539		// associated with the window.	539		// associated with the window.
540	-	func (x *Switch) SetActionName(ActionNameVar string) {	540	+	func (x Switch) SetActionName(ActionNameVar string) {
541			541
542	-	XGtkActionableSetActionName(x.GoPointer(), ActionNameVar)	542	+	XGtkActionableSetActionName(x.GoPointer(), core.NullableStringToPtr(ActionNameVar))
543			543
544		}	544		}
545			545