2014-12-02 23:51:56 +03:00
|
|
|
package qt
|
|
|
|
|
|
|
|
import (
|
2016-10-20 04:25:57 +03:00
|
|
|
"log"
|
|
|
|
"os"
|
2014-12-02 23:51:56 +03:00
|
|
|
"runtime"
|
|
|
|
"strings"
|
2016-04-13 18:33:41 +03:00
|
|
|
"sync"
|
2017-06-13 14:57:44 +03:00
|
|
|
"unsafe"
|
2014-12-02 23:51:56 +03:00
|
|
|
)
|
|
|
|
|
2015-11-12 03:29:32 +03:00
|
|
|
var (
|
2016-10-20 04:25:57 +03:00
|
|
|
Logger = log.New(os.Stderr, "", log.Ltime)
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
signals = make(map[unsafe.Pointer]map[string]unsafe.Pointer)
|
|
|
|
signalsJNI = make(map[string]map[string]unsafe.Pointer)
|
2016-04-13 18:33:41 +03:00
|
|
|
signalsMutex = new(sync.Mutex)
|
2017-06-13 14:57:44 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
objects = make(map[unsafe.Pointer]interface{})
|
2017-06-13 14:57:44 +03:00
|
|
|
objectsMutex = new(sync.Mutex)
|
2017-06-14 17:12:17 +03:00
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
objectsTemp = make(map[unsafe.Pointer]unsafe.Pointer)
|
2017-06-14 17:12:17 +03:00
|
|
|
objectsTempMutex = new(sync.Mutex)
|
2015-11-12 03:29:32 +03:00
|
|
|
)
|
2014-12-02 23:51:56 +03:00
|
|
|
|
|
|
|
func init() { runtime.LockOSThread() }
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
func ExistsSignal(cPtr unsafe.Pointer, signal string) (exists bool) {
|
2016-04-13 18:33:41 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
_, exists = signals[cPtr][signal]
|
2016-04-13 18:33:41 +03:00
|
|
|
signalsMutex.Unlock()
|
2017-07-18 01:35:33 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func LendSignal(cPtr unsafe.Pointer, signal string) (s unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
signalsMutex.Lock()
|
|
|
|
s = signals[cPtr][signal]
|
|
|
|
signalsMutex.Unlock()
|
|
|
|
return
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func lendSignalJNI(cPtr, signal string) (s unsafe.Pointer) {
|
2017-03-02 21:24:25 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
s = signalsJNI[cPtr][signal]
|
2017-03-02 21:24:25 +03:00
|
|
|
signalsMutex.Unlock()
|
2017-07-18 01:35:33 +03:00
|
|
|
return
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func GetSignal(cPtr interface{}, signal string) unsafe.Pointer {
|
2017-07-18 01:35:33 +03:00
|
|
|
if dcPtr, ok := cPtr.(unsafe.Pointer); ok {
|
|
|
|
if signal == "destroyed" || strings.HasPrefix(signal, "~") {
|
|
|
|
defer DisconnectAllSignals(dcPtr, signal)
|
|
|
|
}
|
|
|
|
return LendSignal(dcPtr, signal)
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
2017-07-18 01:35:33 +03:00
|
|
|
return lendSignalJNI(cPtr.(string), signal)
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func ConnectSignal(cPtr interface{}, signal string, function unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if dcPtr, ok := cPtr.(unsafe.Pointer); ok {
|
|
|
|
signalsMutex.Lock()
|
|
|
|
if s, exists := signals[dcPtr]; !exists {
|
2019-04-20 20:34:45 +03:00
|
|
|
signals[dcPtr] = map[string]unsafe.Pointer{signal: function}
|
2017-07-18 01:35:33 +03:00
|
|
|
} else {
|
|
|
|
s[signal] = function
|
|
|
|
}
|
|
|
|
signalsMutex.Unlock()
|
|
|
|
} else {
|
|
|
|
connectSignalJNI(cPtr.(string), signal, function)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func connectSignalJNI(cPtr, signal string, function unsafe.Pointer) {
|
2016-08-24 18:00:49 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
if s, exists := signalsJNI[cPtr]; !exists {
|
2019-04-20 20:34:45 +03:00
|
|
|
signalsJNI[cPtr] = map[string]unsafe.Pointer{signal: function}
|
2017-07-18 01:35:33 +03:00
|
|
|
} else {
|
|
|
|
s[signal] = function
|
|
|
|
}
|
2016-08-24 18:00:49 +03:00
|
|
|
signalsMutex.Unlock()
|
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
func DisconnectSignal(cPtr interface{}, signal string) {
|
|
|
|
if dcPtr, ok := cPtr.(unsafe.Pointer); ok {
|
|
|
|
signalsMutex.Lock()
|
|
|
|
delete(signals[dcPtr], signal)
|
|
|
|
signalsMutex.Unlock()
|
|
|
|
} else {
|
|
|
|
disconnectSignalJNI(cPtr.(string), signal)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func disconnectSignalJNI(cPtr, signal string) {
|
2016-04-13 18:33:41 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
delete(signalsJNI[cPtr], signal)
|
2016-04-13 18:33:41 +03:00
|
|
|
signalsMutex.Unlock()
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
func DisconnectAllSignals(cPtr unsafe.Pointer, signal string) {
|
2017-06-01 00:49:52 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
if s, exists := signals[cPtr]["destroyed"]; signal != "destroyed" && exists {
|
2019-04-20 20:34:45 +03:00
|
|
|
signals[cPtr] = map[string]unsafe.Pointer{"destroyed": s}
|
2017-07-18 01:35:33 +03:00
|
|
|
} else {
|
|
|
|
delete(signals, cPtr)
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
2017-06-01 00:49:52 +03:00
|
|
|
signalsMutex.Unlock()
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
|
|
|
|
2015-11-19 21:29:30 +03:00
|
|
|
func DumpSignals() {
|
2019-04-20 20:34:45 +03:00
|
|
|
Debug("##############################\tSIGNALS_TABLE_START\t##############################")
|
2017-06-01 00:49:52 +03:00
|
|
|
signalsMutex.Lock()
|
2017-07-28 23:05:36 +03:00
|
|
|
for cPtr, entry := range signals {
|
|
|
|
Debug(cPtr, entry)
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
2017-06-01 00:49:52 +03:00
|
|
|
signalsMutex.Unlock()
|
2019-04-20 20:34:45 +03:00
|
|
|
Debug("##############################\tSIGNALS_TABLE_END\t##############################")
|
|
|
|
}
|
|
|
|
|
|
|
|
func DumpObjects() {
|
|
|
|
Debug("##############################\tOBJECTS_TABLE_START\t##############################")
|
|
|
|
objectsMutex.Lock()
|
|
|
|
for cPtr, entry := range objects {
|
|
|
|
Debug(cPtr, entry)
|
|
|
|
}
|
|
|
|
objectsMutex.Unlock()
|
|
|
|
Debug("##############################\tOBJECTS_TABLE_END\t##############################")
|
|
|
|
}
|
|
|
|
|
|
|
|
func DumpTempObjects() {
|
|
|
|
Debug("##############################\tTMP_OBJECTS_TABLE_START\t##############################")
|
|
|
|
objectsTempMutex.Lock()
|
|
|
|
for cPtr, entry := range objectsTemp {
|
|
|
|
Debug(cPtr, entry)
|
|
|
|
}
|
|
|
|
objectsTempMutex.Unlock()
|
|
|
|
Debug("##############################\tTMP_OBJECTS_TABLE_END\t##############################")
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
func CountSignals() (c int) {
|
2017-06-02 17:18:30 +03:00
|
|
|
signalsMutex.Lock()
|
|
|
|
c = len(signals)
|
|
|
|
signalsMutex.Unlock()
|
2017-07-18 01:35:33 +03:00
|
|
|
return
|
2017-06-02 17:18:30 +03:00
|
|
|
}
|
|
|
|
|
2018-11-12 20:38:23 +03:00
|
|
|
func GoBoolToInt(b bool) int8 {
|
2014-12-02 23:51:56 +03:00
|
|
|
if b {
|
2015-10-24 18:18:24 +03:00
|
|
|
return 1
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
2015-10-24 18:18:24 +03:00
|
|
|
return 0
|
2014-12-02 23:51:56 +03:00
|
|
|
}
|
2015-12-15 04:01:51 +03:00
|
|
|
|
2016-10-20 04:25:57 +03:00
|
|
|
func Recover(fn string) {
|
2015-12-15 04:01:51 +03:00
|
|
|
if recover() != nil {
|
2016-10-20 04:25:57 +03:00
|
|
|
Debug("RECOVERED:", fn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func Debug(fn ...interface{}) {
|
2018-10-30 18:53:05 +03:00
|
|
|
if strings.ToLower(os.Getenv("QT_DEBUG")) == "true" || runtime.GOARCH == "js" || runtime.GOARCH == "wasm" {
|
2016-10-20 04:25:57 +03:00
|
|
|
Logger.Println(fn...)
|
2015-12-15 04:01:51 +03:00
|
|
|
}
|
|
|
|
}
|
2017-06-09 02:47:53 +03:00
|
|
|
|
|
|
|
func ClearSignals() {
|
|
|
|
signalsMutex.Lock()
|
2019-04-20 20:34:45 +03:00
|
|
|
signals = make(map[unsafe.Pointer]map[string]unsafe.Pointer)
|
2017-06-09 02:47:53 +03:00
|
|
|
signalsMutex.Unlock()
|
|
|
|
}
|
2017-06-13 14:57:44 +03:00
|
|
|
|
|
|
|
func Register(cPtr unsafe.Pointer, gPtr interface{}) {
|
|
|
|
objectsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
objects[cPtr] = gPtr
|
2017-06-13 14:57:44 +03:00
|
|
|
objectsMutex.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
func Receive(cPtr unsafe.Pointer) (o interface{}, ok bool) {
|
|
|
|
objectsMutex.Lock()
|
2017-07-18 01:35:33 +03:00
|
|
|
o, ok = objects[cPtr]
|
2017-06-13 14:57:44 +03:00
|
|
|
objectsMutex.Unlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
func Unregister(cPtr unsafe.Pointer) {
|
2017-06-13 14:57:44 +03:00
|
|
|
objectsMutex.Lock()
|
|
|
|
delete(objects, cPtr)
|
|
|
|
objectsMutex.Unlock()
|
|
|
|
}
|
2017-06-14 17:12:17 +03:00
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func RegisterTemp(cPtr unsafe.Pointer, gPtr unsafe.Pointer) {
|
2017-06-14 17:12:17 +03:00
|
|
|
objectsTempMutex.Lock()
|
|
|
|
objectsTemp[cPtr] = gPtr
|
|
|
|
objectsTempMutex.Unlock()
|
|
|
|
}
|
|
|
|
|
2019-04-20 20:34:45 +03:00
|
|
|
func ReceiveTemp(cPtr unsafe.Pointer) (o unsafe.Pointer, ok bool) {
|
2017-06-14 17:12:17 +03:00
|
|
|
objectsTempMutex.Lock()
|
|
|
|
o, ok = objectsTemp[cPtr]
|
|
|
|
objectsTempMutex.Unlock()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func UnregisterTemp(cPtr unsafe.Pointer) {
|
|
|
|
objectsTempMutex.Lock()
|
|
|
|
delete(objectsTemp, cPtr)
|
|
|
|
objectsTempMutex.Unlock()
|
|
|
|
}
|