Archives
/
OrbMap
mirror of https://github.com/OrbTools/OrbMap
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

windows now supported

Browse Source
main
Minizbot2012 3 years ago
parent 3d726389ac
commit 3ef3408b56
No known key found for this signature in database
GPG Key ID: 977C8ADE12361917
9 changed files with 186 additions and 154 deletions
Show Stats Download Patch File Download Diff File

30
devices/orbweaver/orbweaver.go
Unescape Escape View File

@ -1,30 +0,0 @@
package orbweaver
import (
"strings"
"github.com/OrbTools/OrbCommon/devices/orbweaver"
)
var eventcodes [26]byte
var ecm map[uint16]int
func init() {
eventcodes = orbweaver.BINDING
ecm = make(map[uint16]int)
}
//ProcOrbFiles processes orbs
func ProcOrbFiles(orbs string) *orbweaver.KeyMaps {
keymaps := &orbweaver.KeyMaps{}
idx := 0
if len(orbs) > 0 {
for _, orb := range strings.Split(orbs, ",") {
KMap := orbweaver.LoadKM(orb)
keymaps.Maps[idx] = KMap
}
} else {
panic("No orbs")
}
return keymaps
}

36
devices/orbweaver/orbweaver_common.go
Unescape Escape View File

@ -0,0 +1,36 @@
package orbweaver
import (
"fmt"
"path/filepath"
"strings"
morb "github.com/OrbTools/OrbCommon/devices/orbweaver"
)
var eventcodes []byte
var ecm map[uint16]int
func init() {
ecm = make(map[uint16]int)
}
//ProcOrbFiles processes orbs
func ProcOrbFiles(orbs string) *morb.KeyMaps {
keymaps := &morb.KeyMaps{Currentmap: 0}
if len(orbs) > 0 {
for idx, orb := range strings.Split(orbs, ";") {
abs, err := filepath.Abs(orb)
if err != nil {
panic(err)
}
fmt.Println("Loading Orb " + abs)
KMap := morb.LoadKM(abs)
keymaps.Maps[idx] = KMap
}
keymaps.MCount = len(orbs)
} else {
panic("No orbs")
}
return keymaps
}

16
devices/orbweaver/orbweaver_linux.go
Unescape Escape View File

@ -1,5 +1,4 @@
//go:generate boxy
//build:+linux
// +build linux !windows
package orbweaver
@ -8,14 +7,17 @@ import (
"encoding/binary"
"os"
morb "github.com/OrbTools/OrbCommon/devices/orbweaver"
"github.com/OrbTools/OrbMap/interface/keyevents"
)
//OrbLoop Main loop for this device
func OrbLoop(km *KeyMaps, KeyBus chan *keyevents.KeyEvent) {
for i := 0; i < 26; i++ {
func OrbLoop(km *morb.KeyMaps, KeyBus chan keyevents.KeyEvent) {
eventcodes = morb.BINDING[:]
for i := 0; i < len(eventcodes); i++ {
ecm[uint16(eventcodes[i])] = i
}
println("UnixLoop starting")
f, err := os.Open("/dev/input/by-id/usb-Razer_Razer_Orbweaver_Chroma-event-kbd")
if err != nil {
panic(err)
@ -24,8 +26,10 @@ func OrbLoop(km *KeyMaps, KeyBus chan *keyevents.KeyEvent) {
b := make([]byte, 24)
for {
f.Read(b)
KeyEv := &keyevents.KeyEvent{}
binary.Read(bytes.NewReader(b[16:]), binary.LittleEndian, &KeyEv)
KeyEv := keyevents.KeyEvent{}
KeyEv.Type = binary.LittleEndian.Uint16(b[16:18])
KeyEv.Code = km.Maps[km.Currentmap].Keymap[ecm[binary.LittleEndian.Uint16(b[18:20])]]
binary.Read(bytes.NewReader(b[20:]), binary.LittleEndian, &KeyEv.Value)
KeyEv.Code = km.Maps[km.Currentmap].Keymap[ecm[KeyEv.Code]]
if KeyEv.Code != 0 && KeyEv.Type != 4 {
KeyBus <- KeyEv

172
devices/orbweaver/orbweaver_windows.go
Unescape Escape View File

@ -1,22 +1,24 @@
//go:generate boxy
//build:+windows
// +build windows
package orbweaver
import (
"bytes"
"encoding/binary"
"encoding/hex"
"fmt"
"github.com/OrbTools/OrbCommon/devices/orbweaver"
morb "github.com/OrbTools/OrbCommon/devices/orbweaver"
"github.com/OrbTools/OrbCommon/hid"
"github.com/OrbTools/OrbMap/interface/keyevents"
"github.com/google/gousb"
)
const (
vendor = gousb.ID(0x1532)
prod = gousb.ID(0x0207)
vendor = gousb.ID(0x1532)
prod = gousb.ID(0x0207)
leftControl byte = 0x1
leftShift byte = 0x2
leftAlt byte = 0x4
)
type swaps struct {
@ -25,23 +27,19 @@ type swaps struct {
}
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,
M1 byte
M2 byte
M3 byte
K1 byte
K2 byte
K3 byte
K4 byte
K5 byte
K6 byte
}
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)
return (s.K1 == k || s.K2 == k || s.K3 == k || s.K4 == k || s.K5 == k || s.K6 == k || s.M1 == k || s.M2 == k || s.M3 == k)
}
func (s *swaps) swap() {
@ -49,48 +47,72 @@ func (s *swaps) swap() {
s.S1 = s.S2
s.S2 = ss
}
func (s *swapInt) Releases(s2 *swapInt) []byte {
func trans(M byte) []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 (M & leftShift) != 0 {
r = append(r, 42)
} else {
r = append(r, 0)
}
if !s.contains(s2.K5) {
r = append(r, s2.K5)
if (M & leftControl) != 0 {
r = append(r, 29)
} else {
r = append(r, 0)
}
if !s.contains(s2.K6) {
r = append(r, s2.K6)
if (M & leftAlt) != 0 {
r = append(r, 56)
} else {
r = append(r, 0)
}
return r
}
func contains(s []byte, e byte) bool {
for _, a := range s {
if a == e {
return true
}
func (s *swapInt) Differ(s2 *swapInt) []byte {
r := make([]byte, 0)
if !s2.contains(s.M1) {
r = append(r, s.M1)
}
if !s2.contains(s.M2) {
r = append(r, s.M2)
}
if !s2.contains(s.M3) {
r = append(r, s.M3)
}
if !s2.contains(s.K1) {
r = append(r, s.K1)
}
if !s2.contains(s.K2) {
r = append(r, s.K2)
}
return false
if !s2.contains(s.K3) {
r = append(r, s.K3)
}
if !s2.contains(s.K4) {
r = append(r, s.K4)
}
if !s2.contains(s.K5) {
r = append(r, s.K5)
}
if !s2.contains(s.K6) {
r = append(r, s.K6)
}
return r
}
//OrbLoop Main loop for this device
func OrbLoop(km *orbweaver.KeyMaps, KeyBus chan *keyevents.KeyEvent) {
for i := 0; i < 26; i++ {
func OrbLoop(km *morb.KeyMaps, KeyBus chan keyevents.KeyEvent) {
eventcodes = morb.BINDING[:]
for i := 0; i < len(eventcodes); i++ {
ecm[uint16(eventcodes[i])] = i
}
fmt.Println("Windows Loop Init")
ctx := gousb.NewContext()
dev, err := ctx.OpenDeviceWithVIDPID(vendor, prod)
if err != nil {
panic(err)
}
fmt.Println("Device connected")
defer dev.Close()
conf, err := dev.Config(1)
if err != nil {
@ -100,51 +122,55 @@ func OrbLoop(km *orbweaver.KeyMaps, KeyBus chan *keyevents.KeyEvent) {
if err != nil {
panic(err)
}
fmt.Println("Windows Loop Interf")
defer intf.Close()
in, err := intf.InEndpoint(1)
if err != nil {
panic(err)
}
fmt.Println("Windows Loop Pointed")
data := make([]byte, in.Desc.MaxPacketSize)
rs, _ := in.NewStream(in.Desc.MaxPacketSize, 3)
swaper := &swaps{}
swaper.S1 = &swapInt{}
swaper.S2 = &swapInt{}
swaper := new(swaps)
swaper.S1 = new(swapInt)
swaper.S2 = new(swapInt)
fmt.Println("Windows Loop Starting")
for {
_, err := rs.Read(data)
if err != nil {
panic(err)
}
for i := 2; i < in.Desc.MaxPacketSize; i++ {
if data[i] != 0 {
data[i] = hid.KEYCODE_WINDOWS_FROM_HID[data[i]]
addin := trans(data[0])
tdat := data[2:]
dat := append(addin, tdat...)
for i := 0; i < len(dat); i++ {
if dat[i] != 0 {
dat[i] = hid.KEYCODE_LINUX_FROM_HID[dat[i]]
dat[i] = byte(km.Maps[km.Currentmap].Keymap[ecm[uint16(dat[i])]])
dat[i] = hid.KEYCODE_LINUX_TO_HID[dat[i]]
dat[i] = hid.KEYCODE_WINDOWS_FROM_HID[dat[i]]
}
}
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 hid.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
}
}
err = binary.Read(bytes.NewReader(dat), binary.LittleEndian, swaper.S1)
if err != nil {
panic(err)
}
for _, pre := range swaper.S1.Differ(swaper.S2) {
if pre != 0 {
KeyEv := keyevents.KeyEvent{}
KeyEv.Code = uint16(pre)
KeyEv.Type = 1
KeyBus <- KeyEv
}
}
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
for _, rel := range swaper.S2.Differ(swaper.S1) {
if rel != 0 {
KeyEv := keyevents.KeyEvent{}
KeyEv.Code = uint16(rel)
KeyEv.Type = 2
KeyBus <- KeyEv
}
}
//Not quite sure how to handle this data quite yet
println(hex.EncodeToString(data))
swaper.swap()
}
}

5
emu/emu_linux.go
Unescape Escape View File

@ -1,4 +1,4 @@
//build:+linux
// +build linux !windows
package emu
@ -10,7 +10,8 @@ import (
var vkm uinput.Keyboard = nil
//ProcKey keyboard emulator loop
func ProcKey(kb chan *keyevents.KeyEvent) {
func ProcKey(kb chan keyevents.KeyEvent) {
println("Emu Unix Starting")
var err error
vkm, err = uinput.CreateKeyboard("/dev/uinput", []byte("Orbmap"))
if err != nil {

62
emu/emu_windows.go
Unescape Escape View File

@ -1,4 +1,4 @@
//build:+windows
// +build windows
package emu
@ -11,50 +11,46 @@ import (
)
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
func downKey(key uint16) {
in := []win.KEYBD_INPUT{
{
Type: win.INPUT_KEYBOARD,
Ki: win.KEYBDINPUT{
DwExtraInfo: 0,
WScan: key,
DwFlags: win.KEYEVENTF_SCANCODE,
Time: 0,
},
},
}
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)))
win.SendInput(1, unsafe.Pointer(&in[0]), int32(unsafe.Sizeof(in[0])))
}
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
func upKey(key uint16) {
in := []win.KEYBD_INPUT{
{
Type: win.INPUT_KEYBOARD,
Ki: win.KEYBDINPUT{
DwExtraInfo: 0,
WScan: key,
DwFlags: win.KEYEVENTF_KEYUP | win.KEYEVENTF_SCANCODE,
Time: 0,
},
},
}
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)))
win.SendInput(1, unsafe.Pointer(&in[0]), int32(unsafe.Sizeof(in[0])))
}
//ProcKey Windows support is so weird
func ProcKey(kb chan *keyevents.KeyEvent) {
func ProcKey(kb chan keyevents.KeyEvent) {
println("Emu Windows Starting")
for {
KeyEv := <-kb
if KeyEv.Type == 1 {
downKey(int(KeyEv.Code))
downKey(KeyEv.Code)
} else if KeyEv.Type == 2 {
upKey(int(KeyEv.Code))
upKey(KeyEv.Code)
}
}
}

2
go.mod
Unescape Escape View File

@ -3,7 +3,7 @@ module github.com/OrbTools/OrbMap
go 1.15
require (
github.com/OrbTools/OrbCommon v0.0.0-20210210011236-0136c0179a2c
github.com/OrbTools/OrbCommon v0.0.0-20210210161232-9ddf46ebcd29
github.com/bendahl/uinput v1.4.0
github.com/google/gousb v1.1.1
github.com/lxn/win v0.0.0-20201111105847-2a20daff6a55

6
go.sum
Unescape Escape View File

@ -1,5 +1,7 @@
github.com/OrbTools/OrbCommon v0.0.0-20210210011236-0136c0179a2c h1:qr1dT3WKovev6HngC7D7PTQzh1gn0+PbH+OGKKq4LNg=
github.com/OrbTools/OrbCommon v0.0.0-20210210011236-0136c0179a2c/go.mod h1:ErdpS2Y/8Ik89IDNsH+yaOWo/XcKzf4riEBfPG3xK+o=
github.com/OrbTools/OrbCommon v0.0.0-20210210155455-6a1a82aeb732 h1:wC1/WUHu23fO4Vkr7NFyTBSD3y5s3x0+1Wb7ywgydP8=
github.com/OrbTools/OrbCommon v0.0.0-20210210155455-6a1a82aeb732/go.mod h1:ErdpS2Y/8Ik89IDNsH+yaOWo/XcKzf4riEBfPG3xK+o=
github.com/OrbTools/OrbCommon v0.0.0-20210210161232-9ddf46ebcd29 h1:Gz3VTOfGkZsza9KVdl6NtVjDKFP1/9A4M8cmkKOcCUQ=
github.com/OrbTools/OrbCommon v0.0.0-20210210161232-9ddf46ebcd29/go.mod h1:ErdpS2Y/8Ik89IDNsH+yaOWo/XcKzf4riEBfPG3xK+o=
github.com/bendahl/uinput v1.4.0 h1:aVJhayM1wEv7yXXLvC/fbXMmA1uB+jAspKhXQaV+76U=
github.com/bendahl/uinput v1.4.0/go.mod h1:Np7w3DINc9wB83p12fTAM3DPPhFnAKP0WTXRqCQJ6Z8=
github.com/google/gousb v1.1.1 h1:2sjwXlc0PIBgDnXtNxUrHcD/RRFOmAtRq4QgnFBE6xc=

11
main.go
Unescape Escape View File

@ -10,13 +10,10 @@ import (
)
func main() {
var orbs *string
orbs = flag.String("orbweaver", "", "Comma seperated string of orbs for the orbweaver")
orbs := flag.String("orbweaver", "", "Comma seperated string of orbs for the orbweaver")
flag.Parse()
KeyBus := make(chan *keyevents.KeyEvent, 128)
if *orbs != "" {
Maps := orbweaver.ProcOrbFiles(*orbs)
go orbweaver.OrbLoop(Maps, KeyBus)
}
KeyBus := make(chan keyevents.KeyEvent, 128)
Maps := orbweaver.ProcOrbFiles(*orbs)
go orbweaver.OrbLoop(Maps, KeyBus)
emu.ProcKey(KeyBus)
}

Write Preview
Loading…
Cancel
Save