modify window go code

drivers/win/driver_windows.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/murlokswarm/app"
 	"github.com/murlokswarm/app/drivers/win/uwp"
-	"github.com/murlokswarm/app/internal/bridge"
 	"github.com/murlokswarm/app/internal/core"
 	"github.com/murlokswarm/app/internal/file"
 	"github.com/pkg/errors"
@@ -219,42 +218,35 @@ func (d *Driver) UI(f func()) {
 	d.ui <- f
 }
 
-func (d *Driver) log(in map[string]interface{}) interface{} {
+func (d *Driver) log(in map[string]interface{}) {
 	msg := in["Msg"].(string)
 	app.Log(msg)
-	return nil
 }
 
-func (d *Driver) onRun(in map[string]interface{}) interface{} {
+func (d *Driver) onRun(in map[string]interface{}) {
 	d.configureDefaultWindow()
 
 	if len(d.URL) != 0 {
 		app.NewWindow(d.DefaultWindow)
 	}
 
 	d.events.Emit(app.Running)
-	return nil
 }
 
-func (d *Driver) onFilesOpen(in map[string]interface{}) interface{} {
-	d.events.Emit(app.OpenFilesRequested, bridge.Strings(in["Filenames"]))
-	return nil
+func (d *Driver) onFilesOpen(in map[string]interface{}) {
+	d.events.Emit(app.OpenFilesRequested, core.ConvertToStringSlice(in["Filenames"]))
 }
 
-func (d *Driver) onURLOpen(in map[string]interface{}) interface{} {
+func (d *Driver) onURLOpen(in map[string]interface{}) {
 	if u, err := url.Parse(in["URL"].(string)); err == nil {
 		d.events.Emit(app.OpenURLRequested, u)
 	}
-
-	return nil
 }
 
-func (d *Driver) onClose(in map[string]interface{}) interface{} {
+func (d *Driver) onClose(in map[string]interface{}) {
 	d.events.Emit(app.Closed)
 
 	d.UI(func() {
 		d.stop()
 	})
-
-	return nil
 }

drivers/win/menu.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/murlokswarm/app"
-	"github.com/murlokswarm/app/internal/bridge"
 	"github.com/murlokswarm/app/internal/core"
 	"github.com/murlokswarm/app/internal/dom"
 	"github.com/pkg/errors"
@@ -137,53 +136,50 @@ func (m *Menu) Type() string {
 	return m.typ
 }
 
-func onMenuCallback(m *Menu, in map[string]interface{}) interface{} {
+func onMenuCallback(m *Menu, in map[string]interface{}) {
 	mappingStr := in["Mapping"].(string)
 
 	var mapping dom.Mapping
 	if err := json.Unmarshal([]byte(mappingStr), &mapping); err != nil {
 		app.Logf("menu callback failed: %s", err)
-		return nil
+		return
 	}
 
 	c, err := m.dom.CompoByID(mapping.CompoID)
 	if err != nil {
 		app.Logf("menu callback failed: %s", err)
-		return nil
+		return
 	}
 
 	var f func()
 	if f, err = mapping.Map(c); err != nil {
 		app.Logf("menu callback failed: %s", err)
-		return nil
+		return
 	}
 
 	if f != nil {
 		f()
-		return nil
+		return
 	}
 
 	app.Render(c)
-	return nil
 }
 
-func onMenuClose(m *Menu, in map[string]interface{}) interface{} {
+func onMenuClose(m *Menu, in map[string]interface{}) {
 	driver.elems.Delete(m)
-	return nil
 }
 
-func handleMenu(h func(m *Menu, in map[string]interface{}) interface{}) bridge.GoRPCHandler {
-	return func(in map[string]interface{}) interface{} {
+func handleMenu(h func(m *Menu, in map[string]interface{})) core.GoHandler {
+	return func(in map[string]interface{}) {
 		id, _ := in["ID"].(string)
 		e := driver.elems.GetByID(id)
 
 		switch m := e.(type) {
 		case *Menu:
-			return h(m, in)
+			h(m, in)
 
 		default:
 			app.Panic("menu not supported")
-			return nil
 		}
 	}
 }

drivers/win/uwp/uwp.cpp

@@ -6,7 +6,4 @@ void winCallReturn(char *retID, char *ret, char *err)
   onWinCallReturn(retID, ret, err);
 }
 
-char *goCall(char *in, char *ui)
-{
-  return onGoCall(in, ui);
-}
+void goCall(char *in) { return onGoCall(in); }

drivers/win/uwp/uwp.go

@@ -8,22 +8,18 @@ package uwp
 import "C"
 
 import (
-	"strconv"
 	"syscall"
 	"unsafe"
 
 	"github.com/murlokswarm/app"
-	"github.com/murlokswarm/app/internal/bridge"
+	"github.com/murlokswarm/app/internal/core"
 	"github.com/pkg/errors"
 )
 
 var (
-	callOnUI func(func())
-	goRPC    bridge.GoRPC
-	winRPC   = bridge.PlatformRPC{
-		Handler: winCall,
-	}
-
+	callOnUI         func(func())
+	platform         = core.Platform{Handler: winCall}
+	golang           core.Go
 	dll              *syscall.DLL
 	winCallReturnPtr unsafe.Pointer
 	goCallPtr        unsafe.Pointer
@@ -56,9 +52,9 @@ func Connect() func() {
 }
 
 // RPC returns rpc objects to achieve two way communication between uwp and Go.
-func RPC(ui func(func())) (*bridge.PlatformRPC, *bridge.GoRPC) {
+func RPC(ui func(func())) (*core.Platform, *core.Go) {
 	callOnUI = ui
-	return &winRPC, &goRPC
+	return &platform, &golang
 }
 
 func winCall(call string) error {
@@ -87,33 +83,20 @@ func callDllFunc(name string, a ...unsafe.Pointer) (uintptr, error) {
 
 //export onWinCallReturn
 func onWinCallReturn(retID, ret, err *C.char) {
-	winRPC.Return(
+	platform.Return(
 		C.GoString(retID),
 		C.GoString(ret),
 		C.GoString(err),
 	)
 }
 
 //export onGoCall
-func onGoCall(ccall *C.char, cui *C.char) (cout *C.char) {
+func onGoCall(ccall *C.char) {
 	call := C.GoString(ccall)
-	ui, _ := strconv.ParseBool(C.GoString(cui))
-
-	if ui {
-		callOnUI(func() {
-			if _, err := goRPC.Call(call); err != nil {
-				app.Panic(errors.Wrap(err, "go call failed"))
-			}
-		})
-
-		return nil
-	}
-
-	ret, err := goRPC.Call(call)
-	if err != nil {
-		app.Panic(errors.Wrap(err, "go call failed"))
-	}
 
-	// Returned string must be free in c++ code.
-	return C.CString(ret)
+	callOnUI(func() {
+		if err := golang.Call(call); err != nil {
+			app.Panic(errors.Wrap(err, "go call failed"))
+		}
+	})
 }

drivers/win/uwp/uwp.hpp

@@ -11,7 +11,7 @@ extern "C" {
 #endif
 
 void winCallReturn(char *retID, char *ret, char *err);
-char *goCall(char *in, char *ui);
+void goCall(char *in);
 
 #ifdef __cplusplus
 }

drivers/win/window.go

@@ -13,7 +13,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/murlokswarm/app"
-	"github.com/murlokswarm/app/internal/bridge"
 	"github.com/murlokswarm/app/internal/core"
 	"github.com/murlokswarm/app/internal/dom"
 	"github.com/murlokswarm/app/internal/file"
@@ -364,92 +363,83 @@ func (w *Window) IsFullScreen() bool {
 	return w.isFullScreen
 }
 
-func onWindowCallback(w *Window, in map[string]interface{}) interface{} {
+func onWindowCallback(w *Window, in map[string]interface{}) {
 	mappingStr := in["Mapping"].(string)
 
 	var m dom.Mapping
 	if err := json.Unmarshal([]byte(mappingStr), &m); err != nil {
 		app.Logf("window callback failed: %s", err)
-		return nil
+		return
 	}
 
 	c, err := w.dom.CompoByID(m.CompoID)
 	if err != nil {
 		app.Logf("window callback failed: %s", err)
-		return nil
+		return
 	}
 
 	var f func()
 	if f, err = m.Map(c); err != nil {
 		app.Logf("window callback failed: %s", err)
-		return nil
+		return
 	}
 
 	if f != nil {
 		f()
-		return nil
+		return
 	}
 
 	app.Render(c)
-	return nil
 }
 
-func onWindowNavigate(w *Window, in map[string]interface{}) interface{} {
+func onWindowNavigate(w *Window, in map[string]interface{}) {
 	e := app.ElemByCompo(w.Compo())
 
 	e.WhenWindow(func(w app.Window) {
 		w.Load(in["URL"].(string))
 	})
-
-	return nil
 }
 
-func onWindowResize(w *Window, in map[string]interface{}) interface{} {
+func onWindowResize(w *Window, in map[string]interface{}) {
 	driver.events.Emit(app.WindowResized, w)
-	return nil
 }
 
-func onWindowFocus(w *Window, in map[string]interface{}) interface{} {
+func onWindowFocus(w *Window, in map[string]interface{}) {
 	w.isFocus = true
 	driver.events.Emit(app.WindowFocused, w)
-	return nil
 }
 
-func onWindowBlur(w *Window, in map[string]interface{}) interface{} {
+func onWindowBlur(w *Window, in map[string]interface{}) {
 	w.isFocus = false
 	driver.events.Emit(app.WindowBlurred, w)
-	return nil
 }
 
-func onWindowFullScreen(w *Window, in map[string]interface{}) interface{} {
+func onWindowFullScreen(w *Window, in map[string]interface{}) {
 	w.isFullScreen = true
 	driver.events.Emit(app.WindowEnteredFullScreen, w)
-	return nil
 }
 
-func onWindowExitFullScreen(w *Window, in map[string]interface{}) interface{} {
+func onWindowExitFullScreen(w *Window, in map[string]interface{}) {
 	w.isFullScreen = false
 	driver.events.Emit(app.WindowExitedFullScreen, w)
-	return nil
 }
 
-func onWindowClose(w *Window, in map[string]interface{}) interface{} {
+func onWindowClose(w *Window, in map[string]interface{}) {
 	driver.events.Emit(app.WindowClosed, w)
 	w.dom.Close()
 	driver.elems.Delete(w)
-	return nil
 }
 
-func handleWindow(h func(w *Window, in map[string]interface{}) interface{}) bridge.GoRPCHandler {
-	return func(in map[string]interface{}) interface{} {
+func handleWindow(h func(w *Window, in map[string]interface{})) core.GoHandler {
+	return func(in map[string]interface{}) {
 		id, _ := in["ID"].(string)
 
 		e := driver.elems.GetByID(id)
 		if e.Err() == app.ErrElemNotSet {
-			return nil
+			return
 		}
 
-		return h(e.(*Window), in)
+		h(e.(*Window), in)
 	}
 }