//export hookListPropertyAppend func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, setIndex C.intptr_t, objp unsafe.Pointer) { fold := (*valueFold)(foldp) slice := listSlice(fold, reflectIndex) var objdv C.DataValue objdv.dataType = C.DTObject *(*unsafe.Pointer)(unsafe.Pointer(&objdv.data)) = objp newslice := append(*slice, unpackDataValue(&objdv, fold.engine).(Object)) if setIndex >= 0 { reflect.ValueOf(fold.gvalue).Method(int(setIndex)).Call([]reflect.Value{reflect.ValueOf(newslice)}) } else { *slice = newslice } }
//export hookListPropertyAppend func hookListPropertyAppend(foldp unsafe.Pointer, reflectIndex, onChangedIndex C.intptr_t, objp unsafe.Pointer) { fold := (*valueFold)(foldp) field := fold.gfield(int(reflectIndex)) slice := field.Addr().Interface().(*[]Object) var objdv C.DataValue objdv.dataType = C.DTObject *(*unsafe.Pointer)(unsafe.Pointer(&objdv.data)) = objp *slice = append(*slice, unpackDataValue(&objdv, fold.engine).(Object)) if onChangedIndex != -1 { // TODO Must probably dereference the ptr here. Test it. reflect.ValueOf(fold.gvalue).Method(int(onChangedIndex)).Call(nil) } }
//export hookGoValueCallMethod func hookGoValueCallMethod(enginep, foldp unsafe.Pointer, reflectIndex C.int, args *C.DataValue) { fold := ensureEngine(enginep, foldp) v := reflect.ValueOf(fold.gvalue) // TODO Must assert that v is necessarily a pointer here, but we shouldn't have to manipulate // gvalue here for that. This should happen in a sensible place in the wrapping functions // that can still error out to the user in due time. method := v.Method(int(reflectIndex)) methodt := method.Type() methodName := v.Type().Method(int(reflectIndex)).Name // TODO Ensure methods with more parameters than this are not registered. var params [C.MaxParams]reflect.Value var err error numIn := methodt.NumIn() for i := 0; i < numIn; i++ { paramdv := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + (uintptr(i)+1)*dataValueSize)) param := reflect.ValueOf(unpackDataValue(paramdv, fold.engine)) if argt := methodt.In(i); param.Type() != argt { param, err = convertParam(methodName, i, param, argt) if err != nil { panic(err.Error()) } } params[i] = param } result := method.Call(params[:numIn]) if len(result) == 1 { packDataValue(result[0].Interface(), args, fold.engine, jsOwner) } else if len(result) > 1 { if len(result) > len(dataValueArray) { panic("function has too many results") } for i, v := range result { packDataValue(v.Interface(), &dataValueArray[i], fold.engine, jsOwner) } args.dataType = C.DTList *(*unsafe.Pointer)(unsafe.Pointer(&args.data)) = C.newVariantList(&dataValueArray[0], C.int(len(result))) } }
//export hookGoValueReadField func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex, setIndex C.int, resultdv *C.DataValue) { fold := ensureEngine(enginep, foldp) var field reflect.Value if getIndex >= 0 { field = reflect.ValueOf(fold.gvalue).Method(int(getIndex)).Call(nil)[0] } else { field = deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex)) } field = deref(field) // Cannot compare Type directly as field may be invalid (nil). if field.Kind() == reflect.Slice && field.Type() == typeObjSlice { // 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)) return } fieldk := field.Kind() if fieldk == reflect.Slice || fieldk == reflect.Struct && field.Type() != typeRGBA { if field.CanAddr() { field = field.Addr() } else if !hashable(field.Interface()) { t := reflect.ValueOf(fold.gvalue).Type() for t.Kind() == reflect.Ptr { t = t.Elem() } panic(fmt.Sprintf("cannot access unaddressable and unhashable struct value on interface field %s.%s; value: %#v", t.Name(), t.Field(int(reflectIndex)).Name, field.Interface())) } } var gvalue interface{} if field.IsValid() { gvalue = field.Interface() } // TODO Strings are being passed in an unsafe manner here. There is a // small chance that the field is changed and the garbage collector is run // before C++ has a chance to look at the data. We can solve this problem // by queuing up values in a stack, and cleaning the stack when the // idle timer fires next. packDataValue(gvalue, resultdv, fold.engine, jsOwner) }
//export hookGoValueCallMethod func hookGoValueCallMethod(enginep, foldp unsafe.Pointer, reflectIndex C.int, args *C.DataValue) { fold := ensureEngine(enginep, foldp) v := reflect.ValueOf(fold.gvalue) // TODO Must assert that v is necessarily a pointer here, but we shouldn't have to manipulate // gvalue here for that. This should happen in a sensible place in the wrapping functions // that can still error out to the user in due time. method := v.Method(int(reflectIndex)) // TODO Ensure methods with more parameters than this are not registered. var params [C.MaximumParamCount - 1]reflect.Value numIn := uintptr(method.Type().NumIn()) for i := uintptr(0); i < numIn; i++ { // TODO Convert the arguments when possible (int32 => int, etc). // TODO Type checking to avoid explosions (or catch the explosion) paramdv := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + (i+1)*dataValueSize)) params[i] = reflect.ValueOf(unpackDataValue(paramdv, fold.engine)) } result := method.Call(params[:numIn]) if len(result) == 1 { packDataValue(result[0].Interface(), args, fold.engine, jsOwner) } else if len(result) > 1 { if len(result) > len(dataValueArray) { panic("function has too many results") } for i, v := range result { packDataValue(v.Interface(), &dataValueArray[i], fold.engine, jsOwner) } args.dataType = C.DTList *(*unsafe.Pointer)(unsafe.Pointer(&args.data)) = C.newVariantList(&dataValueArray[0], C.int(len(result))) } }
// packDataValue packs the provided Go value into a C.DataValue for // shiping into C++ land. // // For simple types (bool, int, etc) value is converted into a // native C++ value. For anything else, including cases when value // has a type that has an underlying simple type, the Go value itself // is encapsulated into a C++ wrapper so that field access and method // calls work. // // This must be run from the main GUI thread due to the cases where // calling wrapGoValue is necessary. func packDataValue(value interface{}, dvalue *C.DataValue, engine *Engine, owner valueOwner) { datap := unsafe.Pointer(&dvalue.data) if value == nil { dvalue.dataType = C.DTInvalid return } switch value := value.(type) { case string: dvalue.dataType = C.DTString cstr, cstrlen := unsafeStringData(value) *(**C.char)(datap) = cstr dvalue.len = cstrlen case bool: dvalue.dataType = C.DTBool *(*bool)(datap) = value case int: if value > 1<<31-1 { dvalue.dataType = C.DTInt64 *(*int64)(datap) = int64(value) } else { dvalue.dataType = C.DTInt32 *(*int32)(datap) = int32(value) } case int64: dvalue.dataType = C.DTInt64 *(*int64)(datap) = value case int32: dvalue.dataType = C.DTInt32 *(*int32)(datap) = value case float64: dvalue.dataType = C.DTFloat64 *(*float64)(datap) = value case float32: dvalue.dataType = C.DTFloat32 *(*float32)(datap) = value case *Common: dvalue.dataType = C.DTObject *(*unsafe.Pointer)(datap) = value.addr case color.RGBA: dvalue.dataType = C.DTColor *(*uint32)(datap) = uint32(value.A)<<24 | uint32(value.R)<<16 | uint32(value.G)<<8 | uint32(value.B) default: dvalue.dataType = C.DTObject if obj, ok := value.(Object); ok { *(*unsafe.Pointer)(datap) = obj.Common().addr } else { *(*unsafe.Pointer)(datap) = wrapGoValue(engine, value, owner) } } }
// packDataValue packs the provided Go value into a C.DataValue for // shiping into C++ land. // // For simple types (bool, int, etc) value is converted into a // native C++ value. For anything else, including cases when value // has a type that has an underlying simple type, the Go value itself // is encapsulated into a C++ wrapper so that field access and method // calls work. // // This must be run from the main GUI thread due to the cases where // calling wrapGoValue is necessary. func packDataValue(value interface{}, dvalue *C.DataValue, engine *Engine, owner valueOwner) { datap := unsafe.Pointer(&dvalue.data) if value == nil { dvalue.dataType = C.DTInvalid return } switch value := value.(type) { case string: dvalue.dataType = C.DTString cstr, cstrlen := unsafeStringData(value) *(**C.char)(datap) = cstr dvalue.len = cstrlen case bool: dvalue.dataType = C.DTBool *(*bool)(datap) = value case int: dvalue.dataType = intDT *(*int)(datap) = value case int64: dvalue.dataType = C.DTInt64 *(*int64)(datap) = value case int32: dvalue.dataType = C.DTInt32 *(*int32)(datap) = value case float64: dvalue.dataType = C.DTFloat64 *(*float64)(datap) = value case float32: dvalue.dataType = C.DTFloat32 *(*float32)(datap) = value case *Object: dvalue.dataType = C.DTObject *(*unsafe.Pointer)(datap) = value.addr default: dvalue.dataType = C.DTObject *(*unsafe.Pointer)(datap) = wrapGoValue(engine, value, owner) } }
// packDataValue packs the provided Go value into a C.DataValue for // shiping into C++ land. // // For simple types (bool, int, etc) value is converted into a // native C++ value. For anything else, including cases when value // has a type that has an underlying simple type, the Go value itself // is encapsulated into a C++ wrapper so that field access and method // calls work. // // This must be run from the main GUI thread due to the cases where // calling wrapGoValue is necessary. func packDataValue(value interface{}, dvalue *C.DataValue, engine *Engine, owner valueOwner) { datap := unsafe.Pointer(&dvalue.data) if value == nil { dvalue.dataType = C.DTInvalid return } switch value := value.(type) { case string: dvalue.dataType = C.DTString cstr, cstrlen := unsafeStringData(value) *(**C.char)(datap) = cstr dvalue.len = cstrlen case bool: dvalue.dataType = C.DTBool *(*bool)(datap) = value case int: if value > 1<<31-1 { dvalue.dataType = C.DTInt64 *(*int64)(datap) = int64(value) } else { dvalue.dataType = C.DTInt32 *(*int32)(datap) = int32(value) } case int64: dvalue.dataType = C.DTInt64 *(*int64)(datap) = value case int32: dvalue.dataType = C.DTInt32 *(*int32)(datap) = value case uint64: dvalue.dataType = C.DTUint64 *(*uint64)(datap) = value case uint32: dvalue.dataType = C.DTUint32 *(*uint32)(datap) = value case float64: dvalue.dataType = C.DTFloat64 *(*float64)(datap) = value case float32: dvalue.dataType = C.DTFloat32 *(*float32)(datap) = value case *Common: dvalue.dataType = C.DTObject *(*unsafe.Pointer)(datap) = value.addr case color.RGBA: dvalue.dataType = C.DTColor *(*uint32)(datap) = uint32(value.A)<<24 | uint32(value.R)<<16 | uint32(value.G)<<8 | uint32(value.B) default: rv := reflect.ValueOf(value) switch rv.Type().Kind() { case reflect.Ptr: rv = rv.Elem() if rv.Kind() != reflect.Array && rv.Kind() != reflect.Slice { break } fallthrough case reflect.Array, reflect.Slice: dvalue.dataType = C.DTVariantList dataValues := make([]C.DataValue, rv.Len()) for i := range dataValues { packDataValue(rv.Index(i).Interface(), &dataValues[i], engine, owner) } switch len(dataValues) { case 0: *(*unsafe.Pointer)(unsafe.Pointer(&dvalue.data)) = C.newVariantList(nil, 0) default: *(*unsafe.Pointer)(unsafe.Pointer(&dvalue.data)) = C.newVariantList(&dataValues[0], C.int(len(dataValues))) } return } dvalue.dataType = C.DTObject if obj, ok := value.(Object); ok { *(*unsafe.Pointer)(datap) = obj.Common().addr } else { *(*unsafe.Pointer)(datap) = wrapGoValue(engine, value, owner) } } }