Fix NewDialogWithFlags; cleaner marshalers

gir/cmd/gir_generate/gendata/gendata.go

@@ -680,6 +680,7 @@ func GtkNewDialog(nsgen *girgen.NamespaceGenerator) error {
 	}
 
 	h := fg.Header()
+	h.Import("unsafe")
 	h.Import("runtime")
 	h.AddCBlock(cGTKDialogNew2)
 
@@ -690,18 +691,18 @@ func GtkNewDialog(nsgen *girgen.NamespaceGenerator) error {
 		// constructor-only dialog flags.
 		//
 		// It is a wrapper around Gtk.Dialog.new_with_buttons in C.
-		func NewDialogWithFlags(title string, parent *gtk.Window, flags gtk.DialogFlags) *gtk.Dialog {
+		func NewDialogWithFlags(title string, parent *Window, flags DialogFlags) *Dialog {
 			ctitle := C.CString(title)
 			defer C.free(unsafe.Pointer(ctitle))
 
 			w := C._gotk4_gtk_dialog_new2(
-				(*C.gchar)(ctitle),
-				(*C.GtkWindow)(parent.Native()),
+				(*C.gchar)(unsafe.Pointer(ctitle)),
+				(*C.GtkWindow)(unsafe.Pointer(parent.Native())),
 				(C.GtkDialogFlags)(flags),
 			)
 			runtime.KeepAlive(parent)
 
-			return wrapDialog(externglib.Take(unsafe.Pointer(c)))
+			return wrapDialog(externglib.Take(unsafe.Pointer(w)))
 		}
 	`)
 

gir/girgen/generators/bitfield.go

@@ -21,9 +21,9 @@ var bitfieldTmpl = gotmpl.NewGoTemplate(`
 		{{ end -}}
 	)
 
-	{{ if .GLibGetType }}
+	{{ if .Marshaler }}
 	func marshal{{.GoName}}(p uintptr) (interface{}, error) {
-		return {{.GoName}}(C.g_value_get_flags((*C.GValue)(unsafe.Pointer(p)))), nil
+		return {{ .GoName }}(externglib.ValueFromNative(unsafe.Pointer(p)).Flags()), nil
 	}
 	{{ end }}
 
@@ -62,8 +62,9 @@ var bitfieldTmpl = gotmpl.NewGoTemplate(`
 
 type bitfieldData struct {
 	*gir.Bitfield
-	GoName string
-	StrLen int // length of all enum strings concatenated
+	GoName    string
+	StrLen    int // length of all enum strings concatenated
+	Marshaler bool
 
 	gen FileGenerator
 }
@@ -104,30 +105,34 @@ func GenerateBitfield(gen FileGeneratorWriter, bitfield *gir.Bitfield) bool {
 	goName := strcases.PascalToGo(bitfield.Name)
 	writer := FileWriterFromType(gen, bitfield)
 
+	data := bitfieldData{
+		Bitfield: bitfield,
+		GoName:   goName,
+		gen:      gen,
+	}
+
 	if bitfield.GLibGetType != "" && !types.FilterCType(gen, bitfield.GLibGetType) {
+		data.Marshaler = true
+		writer.Header().NeedsExternGLib()
 		writer.Header().AddMarshaler(bitfield.GLibGetType, goName)
 	}
 
-	// Need GLibObject for g_value_*.
-	writer.Header().NeedsGLibObject()
 	// Need this for String().
 	writer.Header().Import("strings")
 	writer.Header().Import("fmt")
 
-	data := &bitfieldData{
-		Bitfield: bitfield,
-		GoName:   goName,
-		gen:      gen,
-	}
-
 	for i, member := range bitfield.Members {
 		data.StrLen += len(data.FormatMember(member))
 		if i > 0 {
 			data.StrLen++ // account for '|'
 		}
 	}
 
-	writer.Pen().WriteTmpl(bitfieldTmpl, data)
+	// Cap the StrLen.
+	if data.StrLen > 256 {
+		data.StrLen = 256
+	}
 
+	writer.Pen().WriteTmpl(bitfieldTmpl, &data)
 	return true
 }

gir/girgen/generators/class-interface.go

@@ -55,9 +55,7 @@ var classInterfaceTmpl = gotmpl.NewGoTemplate(`
 
 	{{ if .HasMarshaler }}
 	func marshal{{ .InterfaceName }}(p uintptr) (interface{}, error) {
-		val := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p)))
-		obj := externglib.Take(unsafe.Pointer(val))
-		return {{ $wrapper }}(obj), nil
+		return {{ $wrapper }}(externglib.ValueFromNative(unsafe.Pointer(p)).Object()), nil
 	}
 	{{ end }}
 

gir/girgen/generators/enum.go

@@ -38,9 +38,9 @@ var enumTmpl = gotmpl.NewGoTemplate(`
 	)
 	{{ end }}
 
-	{{ if .GLibGetType }}
+	{{ if .Marshaler }}
 	func marshal{{ .GoName }}(p uintptr) (interface{}, error) {
-		return {{ .GoName }}(C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))), nil
+		return {{ .GoName }}(externglib.ValueFromNative(unsafe.Pointer(p)).Enum()), nil
 	}
 	{{ end }}
 
@@ -58,8 +58,9 @@ var enumTmpl = gotmpl.NewGoTemplate(`
 
 type enumData struct {
 	*gir.Enum
-	GoName string
-	IsIota bool
+	GoName    string
+	IsIota    bool
+	Marshaler bool
 }
 
 var numberMap = map[rune]string{
@@ -137,23 +138,26 @@ func GenerateEnum(gen FileGeneratorWriter, enum *gir.Enum) bool {
 	goName := strcases.PascalToGo(enum.Name)
 	writer := FileWriterFromType(gen, enum)
 
+	data := enumData{
+		Enum:   enum,
+		GoName: goName,
+		IsIota: true,
+	}
+
 	if enum.GLibGetType != "" && !types.FilterCType(gen, enum.GLibGetType) {
+		data.Marshaler = true
+		writer.Header().NeedsExternGLib()
 		writer.Header().AddMarshaler(enum.GLibGetType, goName)
 	}
 
-	isIota := true
 	for i := 0; i < len(enum.Members); i++ {
 		if enum.Members[i].Value != strconv.Itoa(i) {
-			isIota = false
+			data.IsIota = false
 			break
 		}
 	}
 
 	writer.Header().Import("fmt")
-	writer.Pen().WriteTmpl(enumTmpl, &enumData{
-		Enum:   enum,
-		GoName: goName,
-		IsIota: isIota,
-	})
+	writer.Pen().WriteTmpl(enumTmpl, &data)
 	return true
 }

gir/girgen/generators/record.go

@@ -45,10 +45,10 @@ var recordTmpl = gotmpl.NewGoTemplate(`
 		native *C.{{.CType}}
 	}
 
-	{{ if .GLibGetType }}
+	{{ if .Marshaler }}
 	func marshal{{ .GoName }}(p uintptr) (interface{}, error) {
-		b := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p)))
-		return &{{ .GoName }}{&{{ $impl }}{(*C.{{.CType}})(unsafe.Pointer(b))}}, nil
+		b := externglib.ValueFromNative(unsafe.Pointer(p)).Boxed()
+		return &{{ .GoName }}{&{{ $impl }}{(*C.{{.CType}})(b)}}, nil
 	}
 	{{ end }}
 
@@ -161,6 +161,8 @@ func GenerateRecord(gen FileGeneratorWriter, record *gir.Record) bool {
 	writer := FileWriterFromType(gen, record)
 
 	if record.GLibGetType != "" && !types.FilterCType(gen, record.GLibGetType) {
+		recordGen.Marshaler = true
+		writer.Header().NeedsExternGLib()
 		writer.Header().AddMarshaler(record.GLibGetType, recordGen.GoName)
 	}
 
@@ -173,7 +175,8 @@ func GenerateRecord(gen FileGeneratorWriter, record *gir.Record) bool {
 
 type RecordGenerator struct {
 	*gir.Record
-	GoName string
+	GoName    string
+	Marshaler bool
 
 	// TODO: move these out of here.
 	Methods []callable.Generator
@@ -228,16 +231,12 @@ func (rg *RecordGenerator) Header() *file.Header {
 
 func (rg *RecordGenerator) Use(rec *gir.Record) bool {
 	rg.hdr.Reset()
+	rg.Marshaler = false
 
 	if !CanGenerateRecord(rg.gen, rec) {
 		return false
 	}
 
-	if rec.GLibGetType != "" {
-		// Need this for g_value_get_boxed().
-		rg.hdr.NeedsGLibObject()
-	}
-
 	rg.typ.NamespaceFindResult = rg.gen.Namespace()
 	rg.typ.Type = rec