Windows support (until external linking will be supported by go build)

README.md

@@ -1,5 +1,13 @@
 # QML support for the Go language
 
+Notes for neclepsio/qml
+-----------------------
+
+This repository aims to keep go-qml/qml working. It includes several fixed and new features from other repositories
+forked from go-qml, but some of them are just copy and pasted, so the original author for the commit is sometimes lost (sorry!).
+The only fix I wrote are the support for Qt 5.11+ (trivial) and support for Go 1.12.
+
+
 Documentation
 -------------
 

bridge.go

@@ -19,16 +19,16 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"gopkg.in/qml.v1/cdata"
+	"github.com/neclepsio/qml/cdata"
 )
 
 var (
-	guiFunc      = make(chan func())
-	guiDone      = make(chan struct{})
-	guiLock      = 0
-	guiMainRef   uintptr
-	guiPaintRef  uintptr
-	guiIdleRun   int32
+	guiFunc     = make(chan func())
+	guiDone     = make(chan struct{})
+	guiLock     = 0
+	guiMainRef  int64
+	guiPaintRef int64
+	guiIdleRun  int32
 
 	initialized int32
 )
@@ -70,7 +70,7 @@ func Run(f func() error) error {
 // underlying QML logic.
 func RunMain(f func()) {
 	ref := cdata.Ref()
-	if ref == guiMainRef || ref == atomic.LoadUintptr(&guiPaintRef) {
+	if ref == guiMainRef || ref == atomic.LoadInt64(&guiPaintRef) {
 		// Already within the GUI or render threads. Attempting to wait would deadlock.
 		f()
 		return
@@ -203,6 +203,35 @@ type valueFold struct {
 	owner  valueOwner
 }
 
+// cgoFolds holds all fold values that get reference to on the cgo space.
+// Since Go Pointer are not allowed to be held by cgo. We need a lookup
+// table to interface the two space.
+var cgoFolds = make(map[C.GoRef]*valueFold)
+
+// GoRef index the valueFold value and return a lookup
+// key (C.GoRef), so that we can retrieve the fold using
+// the C.GoRef. need to cross between go and cgo
+func (f *valueFold) goRef() C.GoRef {
+	ref := C.GoRef(uintptr(unsafe.Pointer(f)))
+	cgoFolds[ref] = f
+	return ref
+}
+
+// destroyRef remove the valueFold reference from the lookup table.
+func (f *valueFold) destroyRef() {
+	ref := C.GoRef(uintptr(unsafe.Pointer(f)))
+	delete(cgoFolds, ref)
+}
+
+// getFoldFromGoRef return the valueFold value located at ref
+func getFoldFromGoRef(ref C.GoRef) *valueFold {
+	fold := cgoFolds[ref]
+	if fold == nil {
+		panic("cannot find fold go reference")
+	}
+	return fold
+}
+
 type valueOwner uint8
 
 const (
@@ -228,7 +257,7 @@ func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue u
 		panic("cannot hand pointer of pointer to QML logic; use a simple pointer instead")
 	}
 
-	painting := cdata.Ref() == atomic.LoadUintptr(&guiPaintRef)
+	painting := cdata.Ref() == atomic.LoadInt64(&guiPaintRef)
 
 	// Cannot reuse a jsOwner because the QML runtime may choose to destroy
 	// the value _after_ we hand it a new reference to the same value.
@@ -251,7 +280,7 @@ func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue u
 		gvalue: gvalue,
 		owner:  owner,
 	}
-	fold.cvalue = C.newGoValue(unsafe.Pointer(fold), typeInfo(gvalue), parent)
+	fold.cvalue = C.newGoValue(fold.goRef(), typeInfo(gvalue), parent)
 	if prev != nil {
 		// Put new fold first so the single cppOwner, if any, is always the first entry.
 		fold.next = prev
@@ -289,29 +318,37 @@ func addrOf(gvalue interface{}) uintptr {
 var typeNew = make(map[*valueFold]bool)
 
 //export hookGoValueTypeNew
-func hookGoValueTypeNew(cvalue unsafe.Pointer, specp unsafe.Pointer) (foldp unsafe.Pointer) {
+func hookGoValueTypeNew(cvalue unsafe.Pointer, specr C.GoTypeSpec_) (foldr C.GoRef) {
 	// Initialization is postponed until the engine is available, so that
 	// we can hand Init the qml.Object that represents the object.
-	init := reflect.ValueOf((*TypeSpec)(specp).Init)
+	spec := types[specr]
+	if spec == nil {
+		panic("cannot find the specified TypeSpec")
+	}
+
+	init := reflect.ValueOf(spec.Init)
 	fold := &valueFold{
 		init:   init,
 		gvalue: reflect.New(init.Type().In(0).Elem()).Interface(),
 		cvalue: cvalue,
 		owner:  jsOwner,
 	}
+
 	typeNew[fold] = true
 	//fmt.Printf("[DEBUG] value alive (type-created): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
 	stats.valuesAlive(+1)
-	return unsafe.Pointer(fold)
+	return fold.goRef()
 }
 
 //export hookGoValueDestroyed
-func hookGoValueDestroyed(enginep unsafe.Pointer, foldp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
+func hookGoValueDestroyed(enginep unsafe.Pointer, foldr C.GoRef) {
+	fold := getFoldFromGoRef(foldr)
+
 	engine := fold.engine
 	if engine == nil {
 		before := len(typeNew)
 		delete(typeNew, fold)
+		fold.destroyRef()
 		if len(typeNew) == before {
 			panic("destroying value without an associated engine; who created the value?")
 		}
@@ -342,6 +379,7 @@ func hookGoValueDestroyed(enginep unsafe.Pointer, foldp unsafe.Pointer) {
 				delete(engines, engine.addr)
 			}
 		}
+		fold.destroyRef()
 	}
 	//fmt.Printf("[DEBUG] value destroyed: cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
 	stats.valuesAlive(-1)
@@ -360,8 +398,8 @@ func deref(value reflect.Value) reflect.Value {
 }
 
 //export hookGoValueReadField
-func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
+func hookGoValueReadField(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) {
+	fold := ensureEngine(enginep, foldr)
 
 	var field reflect.Value
 	if getIndex >= 0 {
@@ -376,7 +414,7 @@ func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex,
 		// TODO Handle getters that return []qml.Object.
 		// TODO Handle other GoValue slices (!= []qml.Object).
 		resultdv.dataType = C.DTListProperty
-		*(*unsafe.Pointer)(unsafe.Pointer(&resultdv.data)) = C.newListProperty(foldp, C.intptr_t(reflectIndex), C.intptr_t(setIndex))
+		*(*unsafe.Pointer)(unsafe.Pointer(&resultdv.data)) = C.newListProperty(C.GoRef(foldr), C.intptr_t(reflectIndex), C.intptr_t(setIndex))
 		return
 	}
 
@@ -406,8 +444,8 @@ func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex,
 }
 
 //export hookGoValueWriteField
-func hookGoValueWriteField(enginep, foldp unsafe.Pointer, reflectIndex, setIndex C.int, assigndv *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
+func hookGoValueWriteField(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex, setIndex C.int, assigndv *C.DataValue) {
+	fold := ensureEngine(enginep, foldr)
 	v := reflect.ValueOf(fold.gvalue)
 	ve := v
 	for ve.Type().Kind() == reflect.Ptr {
@@ -483,8 +521,8 @@ var (
 )
 
 //export hookGoValueCallMethod
-func hookGoValueCallMethod(enginep, foldp unsafe.Pointer, reflectIndex C.int, args *C.DataValue) {
-	fold := ensureEngine(enginep, foldp)
+func hookGoValueCallMethod(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex C.int, args *C.DataValue) {
+	fold := ensureEngine(enginep, foldr)
 	v := reflect.ValueOf(fold.gvalue)
 
 	// TODO Must assert that v is necessarily a pointer here, but we shouldn't have to manipulate
@@ -548,16 +586,16 @@ func printPaintPanic() {
 }
 
 //export hookGoValuePaint
-func hookGoValuePaint(enginep, foldp unsafe.Pointer, reflectIndex C.intptr_t) {
+func hookGoValuePaint(enginep unsafe.Pointer, foldr C.GoRef, reflectIndex C.intptr_t) {
 	// Besides a convenience this is a workaround for http://golang.org/issue/8588
 	defer printPaintPanic()
-	defer atomic.StoreUintptr(&guiPaintRef, 0)
+	defer atomic.StoreInt64(&guiPaintRef, 0)
 
 	// The main GUI thread is mutex-locked while paint methods are called,
 	// so no two paintings should be happening at the same time.
-	atomic.StoreUintptr(&guiPaintRef, cdata.Ref())
+	atomic.StoreInt64(&guiPaintRef, cdata.Ref())
 
-	fold := ensureEngine(enginep, foldp)
+	fold := ensureEngine(enginep, foldr)
 	if fold.init.IsValid() {
 		return
 	}
@@ -568,8 +606,8 @@ func hookGoValuePaint(enginep, foldp unsafe.Pointer, reflectIndex C.intptr_t) {
 	method.Call([]reflect.Value{reflect.ValueOf(painter)})
 }
 
-func ensureEngine(enginep, foldp unsafe.Pointer) *valueFold {
-	fold := (*valueFold)(foldp)
+func ensureEngine(enginep unsafe.Pointer, foldr C.GoRef) *valueFold {
+	fold := getFoldFromGoRef(foldr)
 	if fold.engine != nil {
 		if fold.init.IsValid() {
 			initGoType(fold)
@@ -605,7 +643,7 @@ func ensureEngine(enginep, foldp unsafe.Pointer) *valueFold {
 }
 
 func initGoType(fold *valueFold) {
-	if cdata.Ref() == atomic.LoadUintptr(&guiPaintRef) {
+	if cdata.Ref() == atomic.LoadInt64(&guiPaintRef) {
 		go RunMain(func() { _initGoType(fold, true) })
 	} else {
 		_initGoType(fold, false)
@@ -637,22 +675,22 @@ func listSlice(fold *valueFold, reflectIndex C.intptr_t) *[]Object {
 }
 
 //export hookListPropertyAt
-func hookListPropertyAt(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, index C.int) (objp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
+func hookListPropertyAt(foldr C.GoRef, reflectIndex, setIndex C.intptr_t, index C.int) (objp unsafe.Pointer) {
+	fold := getFoldFromGoRef(foldr)
 	slice := listSlice(fold, reflectIndex)
 	return (*slice)[int(index)].Common().addr
 }
 
 //export hookListPropertyCount
-func hookListPropertyCount(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) C.int {
-	fold := (*valueFold)(foldp)
+func hookListPropertyCount(foldr C.GoRef, reflectIndex, setIndex C.intptr_t) C.int {
+	fold := getFoldFromGoRef(foldr)
 	slice := listSlice(fold, reflectIndex)
 	return C.int(len(*slice))
 }
 
 //export hookListPropertyAppend
-func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) {
-	fold := (*valueFold)(foldp)
+func hookListPropertyAppend(foldr C.GoRef, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) {
+	fold := getFoldFromGoRef(foldr)
 	slice := listSlice(fold, reflectIndex)
 	var objdv C.DataValue
 	objdv.dataType = C.DTObject
@@ -666,8 +704,8 @@ func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, setIndex C.intpt
 }
 
 //export hookListPropertyClear
-func hookListPropertyClear(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t) {
-	fold := (*valueFold)(foldp)
+func hookListPropertyClear(foldr C.GoRef, reflectIndex, setIndex C.intptr_t) {
+	fold := getFoldFromGoRef(foldr)
 	slice := listSlice(fold, reflectIndex)
 	newslice := (*slice)[0:0]
 	if setIndex >= 0 {

cdata/cdata.go

@@ -1,6 +1,6 @@
 // Package cdata supports the implementation of the qml package.
 package cdata
 
-func Ref() uintptr
+//func Ref() uintptr
 
 func Addrs() (uintptr, uintptr)

cdata/cdata14_386.s

@@ -2,12 +2,14 @@
 
 #include "textflag.h"
 
+/*
 TEXT ·Ref(SB),NOSPLIT,$4-4
 	CALL runtime·acquirem(SB)
 	MOVL 0(SP), AX
 	MOVL AX, ret+0(FP)
 	CALL runtime·releasem(SB)
 	RET
+*/
 
 TEXT ·Addrs(SB),NOSPLIT,$0-8
 	MOVL	$runtime·main(SB), AX

cdata/cdata14_amd64.s

@@ -2,12 +2,14 @@
 
 #include "textflag.h"
 
+/*
 TEXT ·Ref(SB),NOSPLIT,$8-8
 	CALL runtime·acquirem(SB)
 	MOVQ 0(SP), AX
 	MOVQ AX, ret+0(FP)
 	CALL runtime·releasem(SB)
 	RET
+*/
 
 TEXT ·Addrs(SB),NOSPLIT,$0-16
 	MOVQ	$runtime·main(SB), AX

cdata/cdata14_arm.s

@@ -2,13 +2,15 @@
 
 #include "textflag.h"
 
+/*
 TEXT ·Ref(SB),NOSPLIT,$4-4
 	BL runtime·acquirem(SB)
 	MOVW 4(R13), R0
 	MOVW R0, ret+0(FP)
 	MOVW R0, 4(R13)
 	BL runtime·releasem(SB)
 	RET
+*/
 
 TEXT ·Addrs(SB),NOSPLIT,$0-8
 	MOVW	$runtime·main(SB), R0

cdata/cdata_linux.go

@@ -0,0 +1,7 @@
+package cdata
+
+import "syscall"
+
+func Ref() int64 {
+	return int64(syscall.Gettid())
+}

cdata/cdata_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 type refPair struct {
-	ref1, ref2 uintptr
+	ref1, ref2 int64
 }
 
 func TestRef(t *testing.T) {
@@ -28,7 +28,7 @@ func TestRef(t *testing.T) {
 		}()
 	}
 	wg.Wait()
-	refs := make(map[uintptr]bool)
+	refs := make(map[uint32]bool)
 	for i := 0; i < N; i++ {
 		pair := <-ch
 		if pair.ref1 != pair.ref2 {

cdata/cdata_windows.go

@@ -0,0 +1,9 @@
+package cdata
+
+import (
+	"golang.org/x/sys/windows"
+)
+
+func Ref() int64 {
+	return int64(windows.GetCurrentThreadId())
+}

cmd/genqrc/main.go

@@ -44,7 +44,7 @@ import (
 	"path/filepath"
 	"text/template"
 
-	"gopkg.in/qml.v1"
+	"github.com/neclepsio/qml"
 )
 
 const doc = `
@@ -159,14 +159,14 @@ func buildTemplate(name, content string) *template.Template {
 
 var tmpl = buildTemplate("qrc.go", `package {{.PackageName}}
 
-// This file is automatically generated by gopkg.in/qml.v1/cmd/genqrc
+// This file is automatically generated by github.com/neclepsio/qml/cmd/genqrc
 
 import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
 
-	"gopkg.in/qml.v1"
+	"github.com/neclepsio/qml"
 )
 
 func init() {