Work on windows... still WIP

devices/orbweaver/orbweaver.go

@@ -37,6 +37,7 @@ func ProcOrbFiles(orbs string, wd string) *KeyMaps {
 		for _, orb := range strings.Split(orbs, ",") {
 			KMap := &KeyMap{}
 			inf, _ := os.Open(wd + "/" + orb)
+			defer inf.Close()
 			err := binary.Read(inf, binary.LittleEndian, KMap)
 			if err != nil {
 				panic(err)

devices/orbweaver/orbweaver_windows.go

@@ -1,8 +1,9 @@
 package orbweaver
 
 import (
+	"bytes"
+	"encoding/binary"
 	"encoding/hex"
-	"math/big"
 
 	"github.com/google/gousb"
 	"github.com/minizbot2012/orbmap/devices/common"
@@ -14,6 +15,68 @@ const (
 	prod   = gousb.ID(0x0207)
 )
 
+type swaps struct {
+	S1 *swapInt
+	S2 *swapInt
+}
+
+type swapInt struct {
+	Modifier byte
+	Reserved byte
+	K1       byte
+	K2       byte
+	K3       byte
+	K4       byte
+	K5       byte
+	K6       byte
+}
+
+var trans = map[int]int{
+	0: 0,
+	2: 0,
+}
+
+func (s *swapInt) contains(k byte) bool {
+	return (s.K1 == k || s.K2 == k || s.K3 == k || s.K4 == k || s.K5 == k || s.K6 == k)
+}
+
+func (s *swaps) swap() {
+	ss := s.S1
+	s.S1 = s.S2
+	s.S2 = ss
+}
+func (s *swapInt) Releases(s2 *swapInt) []byte {
+	r := make([]byte, 0)
+	if !s.contains(s2.K1) {
+		r = append(r, s2.K1)
+	}
+	if !s.contains(s2.K2) {
+		r = append(r, s2.K2)
+	}
+	if !s.contains(s2.K3) {
+		r = append(r, s2.K3)
+	}
+	if !s.contains((s2.K4)) {
+		r = append(r, s2.K4)
+	}
+	if !s.contains(s2.K5) {
+		r = append(r, s2.K5)
+	}
+	if !s.contains(s2.K6) {
+		r = append(r, s2.K6)
+	}
+	return r
+}
+
+func contains(s []byte, e byte) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}
+
 //OrbLoop Main loop for this device
 func OrbLoop(km *KeyMaps, KeyBus chan *keyevents.KeyEvent) {
 	for i := 0; i < 26; i++ {
@@ -40,26 +103,42 @@ func OrbLoop(km *KeyMaps, KeyBus chan *keyevents.KeyEvent) {
 	}
 	data := make([]byte, in.Desc.MaxPacketSize)
 	rs, _ := in.NewStream(in.Desc.MaxPacketSize, 3)
-	var bits big.Int
+	swaper := &swaps{}
+	swaper.S1 = &swapInt{}
+	swaper.S2 = &swapInt{}
 	for {
 		_, err := rs.Read(data)
 		if err != nil {
 			panic(err)
 		}
 		for i := 2; i < in.Desc.MaxPacketSize; i++ {
-			if common.KEYCODE_WINDOWS_FROM_HID[data[i]] == 255 {
-				data[i] = 0
-			} else {
+			if data[i] != 0 {
 				data[i] = common.KEYCODE_WINDOWS_FROM_HID[data[i]]
 			}
-			if data[i] != 0 && bits.Bit(ecm[uint16(data[i])]) == 0 {
-				KeyEv := &keyevents.KeyEvent{
-					Code: uint16(data[i]),
-					Type: 1,
+		}
+		binary.Read(bytes.NewReader(data), binary.LittleEndian, swaper.S1)
+		//data[0] = trans[data[0]]
+		for i := 2; i < in.Desc.MaxPacketSize; i++ {
+			if data[i] != 0 {
+				if common.KEYCODE_WINDOWS_FROM_HID[data[i]] != 255 {
+					if !swaper.S2.contains(data[i]) {
+						KeyEv := &keyevents.KeyEvent{}
+						KeyEv.Code = uint16(data[i])
+						KeyEv.Type = 1
+						KeyEv.Code = km.Maps[km.Currentmap].Keymap[ecm[KeyEv.Code]]
+						KeyBus <- KeyEv
+					}
 				}
-				bits.SetBit()
-				KeyEv.Code = km.Maps[km.Currentmap].Keymap[ecm[KeyEv.Code]]
-			} else if
+			}
+		}
+		swaper.swap()
+		r := swaper.S2.Releases(swaper.S1)
+		for _, rel := range r {
+			KeyEv := &keyevents.KeyEvent{}
+			KeyEv.Code = uint16(rel)
+			KeyEv.Type = 2
+			KeyEv.Code = km.Maps[km.Currentmap].Keymap[ecm[KeyEv.Code]]
+			KeyBus <- KeyEv
 		}
 		//Not quite sure how to handle this data quite yet
 		println(hex.EncodeToString(data))

keypad/emu_windows.go

@@ -1,23 +1,58 @@
 package keypad
 
 import (
+	"syscall"
 	"unsafe"
 
 	"github.com/lxn/win"
 	"github.com/minizbot2012/orbmap/interface/keyevents"
 )
 
+var user32 = syscall.NewLazyDLL("user32.dll")
+var procKeyBd = user32.NewProc("keybd_event")
+var mapVK = user32.NewProc("MapVirtualKeyA")
+
+func downKey(key int) {
+	flag := 0
+	var in win.KEYBD_INPUT
+	vs, _, _ := mapVK.Call(uintptr(uint32(key)), uintptr(1))
+	vsc := uint16(vs)
+	println(vsc)
+	if vsc == win.VK_SHIFT || vsc == win.VK_CONTROL || vsc == win.VK_MENU {
+		flag |= win.KEYEVENTF_EXTENDEDKEY
+	}
+	in.Type = 1
+	in.Ki.DwExtraInfo = 0
+	in.Ki.DwFlags = uint32(flag)
+	in.Ki.WScan = 0
+	in.Ki.WVk = vsc
+
+	win.SendInput(1, unsafe.Pointer(&in), int32(unsafe.Sizeof(in)))
+}
+func upKey(key int) {
+	flag := win.KEYEVENTF_KEYUP
+	var in win.KEYBD_INPUT
+	vs, _, _ := mapVK.Call(uintptr(uint32(key)), uintptr(1))
+	vsc := uint16(vs)
+	if vsc == win.VK_SHIFT || vsc == win.VK_CONTROL || vsc == win.VK_MENU {
+		flag |= win.KEYEVENTF_EXTENDEDKEY
+	}
+	in.Type = 1
+	in.Ki.DwExtraInfo = 0
+	in.Ki.DwFlags = uint32(flag)
+	in.Ki.WScan = 0
+	in.Ki.WVk = vsc
+	win.SendInput(1, unsafe.Pointer(&in), int32(unsafe.Sizeof(in)))
+}
+
 //ProcKey Windows support is so weird
 func ProcKey(kb chan *keyevents.KeyEvent) {
 	for {
 		KeyEv := <-kb
-		var i win.KEYBD_INPUT
-		i.Type = 1
-		i.Ki.WScan = uint16(KeyEv.Code)
-		i.Ki.DwFlags = 0x8
-		if KeyEv.Type == 2 {
-			i.Ki.DwFlags |= 0x2
+		if KeyEv.Type == 1 {
+			downKey(int(KeyEv.Code))
+		} else if KeyEv.Type == 2 {
+			upKey(int(KeyEv.Code))
 		}
-		win.SendInput(1, unsafe.Pointer(&i), int32(unsafe.Sizeof(i)))
 	}
 }