No more embedded json files, cleaning, and CKI2

pull/3/head
Minizbot2012 4 years ago
parent 2c4cce284a
commit 2e929dc68f
No known key found for this signature in database
GPG Key ID: 977C8ADE12361917

File diff suppressed because one or more lines are too long

@ -1 +0,0 @@
{"KEY_0":48,"KEY_1":49,"KEY_2":50,"KEY_3":51,"KEY_4":52,"KEY_5":53,"KEY_6":54,"KEY_7":55,"KEY_8":56,"KEY_9":57,"KEY_A":65,"KEY_APOSTROPHE":39,"KEY_B":66,"KEY_BACKSLASH":92,"KEY_BACKSPACE":8,"KEY_C":67,"KEY_CAPSLOCK":300,"KEY_COMMA":44,"KEY_D":68,"KEY_DELETE":232,"KEY_DOT":46,"KEY_DOWN":239,"KEY_E":69,"KEY_END":233,"KEY_ENTER":10,"KEY_EQUAL":61,"KEY_ESC":27,"KEY_F":70,"KEY_F1":208,"KEY_F10":217,"KEY_F11":218,"KEY_F12":219,"KEY_F13":220,"KEY_F14":221,"KEY_F15":222,"KEY_F16":223,"KEY_F17":224,"KEY_F18":225,"KEY_F19":226,"KEY_F2":209,"KEY_F20":227,"KEY_F21":228,"KEY_F22":229,"KEY_F23":230,"KEY_F24":231,"KEY_F3":210,"KEY_F4":211,"KEY_F5":212,"KEY_F6":213,"KEY_F7":214,"KEY_F8":215,"KEY_F9":216,"KEY_G":71,"KEY_GRAVE":96,"KEY_H":72,"KEY_HOME":234,"KEY_I":73,"KEY_INSERT":235,"KEY_J":74,"KEY_K":75,"KEY_KP0":48,"KEY_KP1":49,"KEY_KP2":50,"KEY_KP3":51,"KEY_KP4":52,"KEY_KP5":53,"KEY_KP6":54,"KEY_KP7":55,"KEY_KP8":56,"KEY_KP9":57,"KEY_KPASTERISK":46,"KEY_KPDOT":46,"KEY_KPENTER":10,"KEY_KPMINUS":45,"KEY_KPPLUS":43,"KEY_KPSLASH":47,"KEY_L":76,"KEY_LEFT":240,"KEY_LEFTALT":200,"KEY_LEFTBRACE":201,"KEY_LEFTCTRL":202,"KEY_LEFTMETA":243,"KEY_LEFTSHIFT":203,"KEY_LINEFEED":236,"KEY_M":77,"KEY_MINUS":45,"KEY_N":78,"KEY_NUMLOCK":69,"KEY_O":79,"KEY_P":80,"KEY_PAGEDOWN":237,"KEY_PAGEUP":238,"KEY_Q":81,"KEY_R":82,"KEY_RIGHT":241,"KEY_RIGHTALT":204,"KEY_RIGHTBRACE":205,"KEY_RIGHTCTRL":206,"KEY_RIGHTMETA":244,"KEY_RIGHTSHIFT":206,"KEY_S":83,"KEY_SCROLLLOCK":207,"KEY_SEMICOLON":59,"KEY_SLASH":47,"KEY_SPACE":32,"KEY_T":84,"KEY_TAB":9,"KEY_U":85,"KEY_UP":242,"KEY_V":86,"KEY_W":87,"KEY_X":88,"KEY_Y":89,"KEY_Z":90,"NONE":0}

@ -1 +0,0 @@
{"KEY_0":11,"KEY_1":2,"KEY_2":3,"KEY_3":4,"KEY_4":5,"KEY_5":6,"KEY_6":7,"KEY_7":8,"KEY_8":9,"KEY_9":10,"KEY_A":30,"KEY_APOSTROPHE":40,"KEY_B":48,"KEY_BACKSLASH":43,"KEY_BACKSPACE":14,"KEY_C":46,"KEY_CAPSLOCK":58,"KEY_COMMA":51,"KEY_D":32,"KEY_DELETE":111,"KEY_DOT":52,"KEY_DOWN":108,"KEY_E":18,"KEY_END":107,"KEY_ENTER":28,"KEY_EQUAL":13,"KEY_ESC":1,"KEY_F":33,"KEY_F1":59,"KEY_F10":68,"KEY_F11":87,"KEY_F12":88,"KEY_F13":183,"KEY_F14":184,"KEY_F15":185,"KEY_F16":186,"KEY_F17":187,"KEY_F18":188,"KEY_F19":189,"KEY_F2":60,"KEY_F20":190,"KEY_F21":191,"KEY_F22":192,"KEY_F23":193,"KEY_F24":194,"KEY_F3":61,"KEY_F4":62,"KEY_F5":63,"KEY_F6":64,"KEY_F7":65,"KEY_F8":66,"KEY_F9":67,"KEY_G":34,"KEY_GRAVE":41,"KEY_H":35,"KEY_HOME":102,"KEY_I":23,"KEY_INSERT":110,"KEY_J":36,"KEY_K":37,"KEY_KP0":82,"KEY_KP1":79,"KEY_KP2":80,"KEY_KP3":81,"KEY_KP4":75,"KEY_KP5":76,"KEY_KP6":77,"KEY_KP7":71,"KEY_KP8":72,"KEY_KP9":73,"KEY_KPASTERISK":55,"KEY_KPDOT":83,"KEY_KPENTER":96,"KEY_KPMINUS":74,"KEY_KPPLUS":78,"KEY_KPSLASH":98,"KEY_L":38,"KEY_LEFT":105,"KEY_LEFTALT":56,"KEY_LEFTBRACE":26,"KEY_LEFTCTRL":29,"KEY_LEFTMETA":125,"KEY_LEFTSHIFT":42,"KEY_LINEFEED":101,"KEY_M":50,"KEY_MINUS":12,"KEY_N":49,"KEY_NUMLOCK":69,"KEY_O":24,"KEY_P":25,"KEY_PAGEDOWN":109,"KEY_PAGEUP":104,"KEY_Q":16,"KEY_R":19,"KEY_RIGHT":106,"KEY_RIGHTALT":100,"KEY_RIGHTBRACE":27,"KEY_RIGHTCTRL":97,"KEY_RIGHTMETA":126,"KEY_RIGHTSHIFT":54,"KEY_S":31,"KEY_SCROLLLOCK":70,"KEY_SEMICOLON":39,"KEY_SLASH":53,"KEY_SPACE":57,"KEY_T":20,"KEY_TAB":15,"KEY_U":22,"KEY_UP":103,"KEY_V":47,"KEY_W":17,"KEY_X":45,"KEY_Y":21,"KEY_Z":44,"NONE":0}

@ -9,8 +9,8 @@ import (
//PKM format for altering the keymap
type PKM struct {
MIP [20]int
SIP [6]int
MIP [20]uint16
SIP [6]uint16
COL [3]int
}
@ -19,9 +19,9 @@ func SaveIntoKeymap(mapped *PKM, file fyne.URIWriteCloser) {
buf := make([]byte, 2)
for i := 0; i < 26; i++ {
if i < 20 {
binary.LittleEndian.PutUint16(buf, uint16(keys.GetSCForASCII(int(mapped.MIP[i]))))
binary.LittleEndian.PutUint16(buf, uint16(keys.GetSCForASCII(mapped.MIP[i])))
} else {
binary.LittleEndian.PutUint16(buf, uint16(keys.GetSCForASCII(int(mapped.SIP[i-20]))))
binary.LittleEndian.PutUint16(buf, uint16(keys.GetSCForASCII(mapped.SIP[i-20])))
}
file.Write(buf)
}
@ -36,7 +36,8 @@ func LoadFile(file fyne.URIReadCloser) *PKM {
for i := 0; i < 26; i++ {
b := make([]byte, 2)
file.Read(b)
Asc := keys.GetASCIIForSC(int(binary.LittleEndian.Uint16(b)))
Asc := keys.GetASCIIForSC(binary.LittleEndian.Uint16(b))
println(string(Asc))
if i < 26 {
if i < 20 {
mapped.MIP[i] = Asc

@ -1,49 +0,0 @@
package keys
import (
"fmt"
"strings"
"fyne.io/fyne"
)
//CKIFIsCMPLX Determines whether or not to shorten
func CKIFIsCMPLX(e fyne.KeyName) bool {
_, ok := FyneToASCII[e]
return ok
}
//CKIAIsCMPLX Determines whether or not to shorten in revo
func CKIAIsCMPLX(i int) bool {
_, ok := ASCIIToFyne[i]
return ok
}
//CKIFyneKeyMap Control Keys interop
func CKIFyneKeyMap(e fyne.KeyName) int {
fmt.Println(e)
if val, ok := FyneToASCII[e]; ok {
return val
}
return CommonToASCII["KEY_"+strings.ToUpper(string(e))]
}
//CKICommonName returns common name for ascii
func CKICommonName(r int) string {
return ASCIIToCommon[r]
}
//CKIASCIIIsPrintable returns true if the ascii is in the printable range
func CKIASCIIIsPrintable(r int) bool {
return r > 32 && r < 127
}
//CKIName returns the character name, or character if printable for item r
func CKIName(r int) string {
if r == CommonToASCII["KEY_SPACE"] {
return ASCIIToCommon[r]
} else if CKIASCIIIsPrintable(r) {
return string(r)
}
return ASCIIToCommon[r]
}

@ -0,0 +1,129 @@
package keys
// Common Interface 2, natified go
import (
"fyne.io/fyne"
"fyne.io/fyne/driver/desktop"
)
//ASCIIToKC -- ASCII Value to a KBD Scancode
var ASCIIToKC = map[rune]Code{
'a': CodeA,
'b': CodeB,
'c': CodeC,
'd': CodeD,
'e': CodeE,
'f': CodeF,
'g': CodeG,
'h': CodeH,
'i': CodeI,
'k': CodeK,
'l': CodeL,
'm': CodeM,
'n': CodeN,
'o': CodeO,
'p': CodeP,
'r': CodeR,
's': CodeS,
't': CodeT,
'u': CodeU,
'v': CodeV,
'w': CodeW,
'x': CodeX,
'y': CodeY,
'z': CodeZ,
'0': Code0,
'1': Code1,
'2': Code2,
'3': Code3,
'4': Code4,
'5': Code5,
'6': Code6,
'7': Code7,
'8': Code8,
'9': Code9,
' ': CodeSpace,
'-': CodeMinus,
'=': CodeEqual,
'[': CodeLeftBrack,
']': CodeRightBrace,
'\\': CodeBackslash,
';': CodeSemicolon,
'\'': CodeApostrophe,
'`': CodeGrave,
',': CodeComma,
'.': CodeDot,
'/': CodeSlash,
}
//FyneToKC - conversion between fyne to ode
var FyneToKC = map[fyne.KeyName]Code{
fyne.Key0: Code0,
fyne.Key1: Code1,
fyne.Key2: Code2,
fyne.Key3: Code3,
fyne.Key4: Code4,
fyne.Key5: Code5,
fyne.Key6: Code6,
fyne.Key7: Code7,
fyne.Key8: Code8,
fyne.Key9: Code9,
fyne.KeyA: CodeA,
fyne.KeyB: CodeB,
fyne.KeyC: CodeC,
fyne.KeyD: CodeD,
fyne.KeyE: CodeE,
fyne.KeyF: CodeF,
fyne.KeyG: CodeG,
fyne.KeyH: CodeH,
fyne.KeyI: CodeI,
fyne.KeyJ: CodeJ,
fyne.KeyK: CodeK,
fyne.KeyL: CodeL,
fyne.KeyM: CodeM,
fyne.KeyN: CodeN,
fyne.KeyO: CodeO,
fyne.KeyP: CodeP,
fyne.KeyQ: CodeQ,
fyne.KeyR: CodeR,
fyne.KeyS: CodeS,
fyne.KeyT: CodeT,
fyne.KeyU: CodeU,
fyne.KeyV: CodeV,
fyne.KeyW: CodeW,
fyne.KeyX: CodeX,
fyne.KeyY: CodeY,
fyne.KeyZ: CodeZ,
fyne.KeyUp: CodeUpArrow,
fyne.KeyDown: CodeDownArrow,
fyne.KeyRight: CodeRightArrow,
fyne.KeyLeft: CodeLeftArrow,
fyne.KeyEnd: CodeEnd,
fyne.KeyHome: CodeHome,
fyne.KeyInsert: CodeInsert,
fyne.KeyDelete: CodeDelete,
fyne.KeyEnter: CodeEnter,
fyne.KeyTab: CodeTab,
fyne.KeyEscape: CodeESC,
fyne.KeyF1: CodeF1,
fyne.KeyF2: CodeF2,
fyne.KeyF3: CodeF3,
fyne.KeyF4: CodeF4,
fyne.KeyF5: CodeF5,
fyne.KeyF6: CodeF6,
fyne.KeyF7: CodeF7,
fyne.KeyF8: CodeF8,
fyne.KeyF9: CodeF9,
fyne.KeyF10: CodeF10,
fyne.KeyF11: CodeF11,
fyne.KeyF12: CodeF12,
fyne.KeyPageDown: CodePageDown,
fyne.KeyPageUp: CodePageUp,
fyne.KeySpace: CodeSpace,
desktop.KeyAltLeft: CodeLeftAlt,
desktop.KeyAltRight: CodeRightAlt,
desktop.KeyControlLeft: CodeLeftCntl,
desktop.KeyControlRight: CodeRightControl,
desktop.KeyShiftLeft: CodeLeftShift,
desktop.KeyShiftRight: CodeRightShift,
}

@ -0,0 +1,146 @@
// Code generated by "stringer --type Code"; DO NOT EDIT.
package keys
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[CodeESC-1]
_ = x[Code1-2]
_ = x[Code2-3]
_ = x[Code3-4]
_ = x[Code4-5]
_ = x[Code5-6]
_ = x[Code6-7]
_ = x[Code7-8]
_ = x[Code8-9]
_ = x[Code9-10]
_ = x[Code0-11]
_ = x[CodeMinus-12]
_ = x[CodeEqual-13]
_ = x[CodeBackspace-14]
_ = x[CodeTab-15]
_ = x[CodeQ-16]
_ = x[CodeW-17]
_ = x[CodeE-18]
_ = x[CodeR-19]
_ = x[CodeT-20]
_ = x[CodeY-21]
_ = x[CodeU-22]
_ = x[CodeI-23]
_ = x[CodeO-24]
_ = x[CodeP-25]
_ = x[CodeLeftBrack-26]
_ = x[CodeRightBrace-27]
_ = x[CodeEnter-28]
_ = x[CodeLeftCntl-29]
_ = x[CodeA-30]
_ = x[CodeS-31]
_ = x[CodeD-32]
_ = x[CodeF-33]
_ = x[CodeG-34]
_ = x[CodeH-35]
_ = x[CodeJ-36]
_ = x[CodeK-37]
_ = x[CodeL-38]
_ = x[CodeSemicolon-39]
_ = x[CodeApostrophe-40]
_ = x[CodeGrave-41]
_ = x[CodeLeftShift-42]
_ = x[CodeBackslash-43]
_ = x[CodeZ-44]
_ = x[CodeX-45]
_ = x[CodeC-46]
_ = x[CodeV-47]
_ = x[CodeB-48]
_ = x[CodeN-49]
_ = x[CodeM-50]
_ = x[CodeComma-51]
_ = x[CodeDot-52]
_ = x[CodeSlash-53]
_ = x[CodeRightShift-54]
_ = x[CodeKPAsterisk-55]
_ = x[CodeLeftAlt-56]
_ = x[CodeSpace-57]
_ = x[CodeCapsLock-58]
_ = x[CodeF1-59]
_ = x[CodeF2-60]
_ = x[CodeF3-61]
_ = x[CodeF4-62]
_ = x[CodeF5-63]
_ = x[CodeF6-64]
_ = x[CodeF7-65]
_ = x[CodeF8-66]
_ = x[CodeF9-67]
_ = x[CodeF10-68]
_ = x[CodeNumlock-69]
_ = x[CodeScrollLock-70]
_ = x[CodeKP7-71]
_ = x[CodeKP8-72]
_ = x[CodeKP9-73]
_ = x[CodeKPMinus-74]
_ = x[CodeKP4-75]
_ = x[CodeKP5-76]
_ = x[CodeKP6-77]
_ = x[CodeKPPlus-78]
_ = x[CodeKP1-79]
_ = x[CodeKP2-80]
_ = x[CodeKP3-81]
_ = x[CodeKP0-82]
_ = x[CodeKPDot-83]
_ = x[CodeF11-87]
_ = x[CodeF12-88]
_ = x[CodeKPEnter-96]
_ = x[CodeRightControl-97]
_ = x[CodeKPSlash-98]
_ = x[CodeRightAlt-100]
_ = x[CodeHome-102]
_ = x[CodeUpArrow-103]
_ = x[CodePageUp-104]
_ = x[CodeLeftArrow-105]
_ = x[CodeRightArrow-106]
_ = x[CodeEnd-107]
_ = x[CodeDownArrow-108]
_ = x[CodePageDown-109]
_ = x[CodeInsert-110]
_ = x[CodeDelete-111]
}
const (
_Code_name_0 = "CodeESCCode1Code2Code3Code4Code5Code6Code7Code8Code9Code0CodeMinusCodeEqualCodeBackspaceCodeTabCodeQCodeWCodeECodeRCodeTCodeYCodeUCodeICodeOCodePCodeLeftBrackCodeRightBraceCodeEnterCodeLeftCntlCodeACodeSCodeDCodeFCodeGCodeHCodeJCodeKCodeLCodeSemicolonCodeApostropheCodeGraveCodeLeftShiftCodeBackslashCodeZCodeXCodeCCodeVCodeBCodeNCodeMCodeCommaCodeDotCodeSlashCodeRightShiftCodeKPAsteriskCodeLeftAltCodeSpaceCodeCapsLockCodeF1CodeF2CodeF3CodeF4CodeF5CodeF6CodeF7CodeF8CodeF9CodeF10CodeNumlockCodeScrollLockCodeKP7CodeKP8CodeKP9CodeKPMinusCodeKP4CodeKP5CodeKP6CodeKPPlusCodeKP1CodeKP2CodeKP3CodeKP0CodeKPDot"
_Code_name_1 = "CodeF11CodeF12"
_Code_name_2 = "CodeKPEnterCodeRightControlCodeKPSlash"
_Code_name_3 = "CodeRightAlt"
_Code_name_4 = "CodeHomeCodeUpArrowCodePageUpCodeLeftArrowCodeRightArrowCodeEndCodeDownArrowCodePageDownCodeInsertCodeDelete"
)
var (
_Code_index_0 = [...]uint16{0, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57, 66, 75, 88, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 158, 172, 181, 193, 198, 203, 208, 213, 218, 223, 228, 233, 238, 251, 265, 274, 287, 300, 305, 310, 315, 320, 325, 330, 335, 344, 351, 360, 374, 388, 399, 408, 420, 426, 432, 438, 444, 450, 456, 462, 468, 474, 481, 492, 506, 513, 520, 527, 538, 545, 552, 559, 569, 576, 583, 590, 597, 606}
_Code_index_1 = [...]uint8{0, 7, 14}
_Code_index_2 = [...]uint8{0, 11, 27, 38}
_Code_index_4 = [...]uint8{0, 8, 19, 29, 42, 56, 63, 76, 88, 98, 108}
)
func (i Code) String() string {
switch {
case 1 <= i && i <= 83:
i -= 1
return _Code_name_0[_Code_index_0[i]:_Code_index_0[i+1]]
case 87 <= i && i <= 88:
i -= 87
return _Code_name_1[_Code_index_1[i]:_Code_index_1[i+1]]
case 96 <= i && i <= 98:
i -= 96
return _Code_name_2[_Code_index_2[i]:_Code_index_2[i+1]]
case i == 100:
return _Code_name_3
case 102 <= i && i <= 111:
i -= 102
return _Code_name_4[_Code_index_4[i]:_Code_index_4[i+1]]
default:
return "Code(" + strconv.FormatInt(int64(i), 10) + ")"
}
}

@ -1,94 +1,49 @@
package keys
import (
"encoding/json"
"fmt"
"strconv"
"fyne.io/fyne"
"fyne.io/fyne/driver/desktop"
"github.com/minizbot2012/orbbind/box"
)
//Key Codes Map
var (
ScanToCommon map[int]string
ASCIIToCommon map[int]string
CommonToScan map[string]int
CommonToASCII map[string]int
FyneToASCII map[fyne.KeyName]int
ASCIIToFyne map[int]fyne.KeyName
//KCToASCII keycode to ascii table
KCToASCII map[Code]rune
)
func genStatics() {
FyneToASCII[fyne.KeyUp] = CommonToASCII["KEY_UP"]
FyneToASCII[fyne.KeyDown] = CommonToASCII["KEY_DOWN"]
FyneToASCII[fyne.KeyRight] = CommonToASCII["KEY_RIGHT"]
FyneToASCII[fyne.KeyLeft] = CommonToASCII["KEY_LEFT"]
FyneToASCII[fyne.KeyEnd] = CommonToASCII["KEY_END"]
FyneToASCII[fyne.KeyHome] = CommonToASCII["KEY_HOME"]
FyneToASCII[fyne.KeyInsert] = CommonToASCII["KEY_INSERT"]
FyneToASCII[fyne.KeyDelete] = CommonToASCII["KEY_DELETE"]
FyneToASCII[fyne.KeyEnter] = CommonToASCII["KEY_ENTER"]
FyneToASCII[fyne.KeyTab] = CommonToASCII["KEY_TAB"]
FyneToASCII[fyne.KeyEscape] = CommonToASCII["KEY_ESC"]
FyneToASCII[fyne.KeyF1] = CommonToASCII["KEY_F1"]
FyneToASCII[fyne.KeyF2] = CommonToASCII["KEY_F2"]
FyneToASCII[fyne.KeyF3] = CommonToASCII["KEY_F3"]
FyneToASCII[fyne.KeyF4] = CommonToASCII["KEY_F4"]
FyneToASCII[fyne.KeyF5] = CommonToASCII["KEY_F5"]
FyneToASCII[fyne.KeyF6] = CommonToASCII["KEY_F6"]
FyneToASCII[fyne.KeyF7] = CommonToASCII["KEY_F7"]
FyneToASCII[fyne.KeyF8] = CommonToASCII["KEY_F8"]
FyneToASCII[fyne.KeyF9] = CommonToASCII["KEY_F9"]
FyneToASCII[fyne.KeyF10] = CommonToASCII["KEY_F10"]
FyneToASCII[fyne.KeyF11] = CommonToASCII["KEY_F11"]
FyneToASCII[fyne.KeyF12] = CommonToASCII["KEY_F12"]
FyneToASCII[fyne.KeyPageDown] = CommonToASCII["KEY_PAGEDOWN"]
FyneToASCII[fyne.KeyPageUp] = CommonToASCII["KEY_PAGEUP"]
FyneToASCII[fyne.KeySpace] = CommonToASCII["KEY_SPACE"]
FyneToASCII[desktop.KeyAltLeft] = CommonToASCII["KEY_LEFTALT"]
FyneToASCII[desktop.KeyAltRight] = CommonToASCII["KEY_RIGHTALT"]
FyneToASCII[desktop.KeyControlLeft] = CommonToASCII["KEY_LEFTCTRL"]
FyneToASCII[desktop.KeyControlRight] = CommonToASCII["KEY_RIGHTCTRL"]
FyneToASCII[desktop.KeyShiftLeft] = CommonToASCII["KEY_LEFTSHIFT"]
FyneToASCII[desktop.KeyShiftRight] = CommonToASCII["KEY_RIGHTSHIFT"]
}
func genMap() {
ASCII := box.Get("ascii.json")
SC := box.Get("scancodes.json")
json.Unmarshal(ASCII, &CommonToASCII)
json.Unmarshal(SC, &CommonToScan)
for k, v := range CommonToASCII {
ASCIIToCommon[v] = k
}
for k, v := range CommonToScan {
ScanToCommon[v] = k
}
genStatics()
for k, v := range FyneToASCII {
ASCIIToFyne[v] = k
}
}
//GetASCIIForSC Returns Ascii for Scancode
func GetASCIIForSC(r int) int {
return CommonToASCII[ScanToCommon[r]]
func GetASCIIForSC(r uint16) uint16 {
return uint16(KCToASCII[Code(r)])
}
//GetSCForASCII Returns scancode For Ascii
func GetSCForASCII(r int) int {
return CommonToScan[ASCIIToCommon[r]]
func GetSCForASCII(r uint16) uint16 {
return uint16(ASCIIToKC[rune(r)])
}
func init() {
ScanToCommon = make(map[int]string)
ASCIIToCommon = make(map[int]string)
KCToASCII = make(map[Code]rune)
for x, y := range ASCIIToKC {
fmt.Println(string(x) + ":" + strconv.Itoa(int(y)))
KCToASCII[y] = x
}
}
CommonToScan = make(map[string]int)
CommonToASCII = make(map[string]int)
//CKIFyneKeyMap Control Keys interop
func CKIFyneKeyMap(e fyne.KeyName) uint16 {
if val, ok := KCToASCII[FyneToKC[e]]; ok {
return uint16(val)
}
return 0
}
//CKIKeyNameFromKC Key Name from Keycode
func CKIKeyNameFromKC(r uint16) string {
return Code(r).String()[4:]
}
FyneToASCII = make(map[fyne.KeyName]int)
ASCIIToFyne = make(map[int]fyne.KeyName)
genMap()
//CKIKeyNameFromASCII key name from ascii code
func CKIKeyNameFromASCII(r uint16) string {
return ASCIIToKC[rune(r)].String()[4:]
}

@ -0,0 +1,109 @@
//go:generate stringer --type Code
//Package keys provides back end keymapping
package keys
//Code ScanCode object
type Code uint16
const (
CodeNone uint16 = 0
CodeESC Code = 1
Code1 Code = 2
Code2 Code = 3
Code3 Code = 4
Code4 Code = 5
Code5 Code = 6
Code6 Code = 7
Code7 Code = 8
Code8 Code = 9
Code9 Code = 10
Code0 Code = 11
CodeMinus Code = 12
CodeEqual Code = 13
CodeBackspace Code = 14
CodeTab Code = 15
CodeQ Code = 16
CodeW Code = 17
CodeE Code = 18
CodeR Code = 19
CodeT Code = 20
CodeY Code = 21
CodeU Code = 22
CodeI Code = 23
CodeO Code = 24
CodeP Code = 25
CodeLeftBrack Code = 26
CodeRightBrace Code = 27
CodeEnter Code = 28
CodeLeftCntl Code = 29
CodeA Code = 30
CodeS Code = 31
CodeD Code = 32
CodeF Code = 33
CodeG Code = 34
CodeH Code = 35
CodeJ Code = 36
CodeK Code = 37
CodeL Code = 38
CodeSemicolon Code = 39
CodeApostrophe Code = 40
CodeGrave Code = 41
CodeLeftShift Code = 42
CodeBackslash Code = 43
CodeZ Code = 44
CodeX Code = 45
CodeC Code = 46
CodeV Code = 47
CodeB Code = 48
CodeN Code = 49
CodeM Code = 50
CodeComma Code = 51
CodeDot Code = 52
CodeSlash Code = 53
CodeRightShift Code = 54
CodeKPAsterisk Code = 55
CodeLeftAlt Code = 56
CodeSpace Code = 57
CodeCapsLock Code = 58
CodeF1 Code = 59
CodeF2 Code = 60
CodeF3 Code = 61
CodeF4 Code = 62
CodeF5 Code = 63
CodeF6 Code = 64
CodeF7 Code = 65
CodeF8 Code = 66
CodeF9 Code = 67
CodeF10 Code = 68
CodeNumlock Code = 69
CodeScrollLock Code = 70
CodeKP7 Code = 71
CodeKP8 Code = 72
CodeKP9 Code = 73
CodeKPMinus Code = 74
CodeKP4 Code = 75
CodeKP5 Code = 76
CodeKP6 Code = 77
CodeKPPlus Code = 78
CodeKP1 Code = 79
CodeKP2 Code = 80
CodeKP3 Code = 81
CodeKP0 Code = 82
CodeKPDot Code = 83
CodeF11 Code = 87
CodeF12 Code = 88
CodeKPEnter Code = 96
CodeRightControl Code = 97
CodeKPSlash Code = 98
CodeRightAlt Code = 100
CodeHome Code = 102
CodeUpArrow Code = 103
CodePageUp Code = 104
CodeLeftArrow Code = 105
CodeRightArrow Code = 106
CodeEnd Code = 107
CodeDownArrow Code = 108
CodePageDown Code = 109
CodeInsert Code = 110
CodeDelete Code = 111
)

Binary file not shown.

@ -1,5 +1,3 @@
//go:generate boxy
package main
import (

@ -12,7 +12,7 @@ import (
//BindingInfo Genral data to use in a channel
type BindingInfo struct {
Bindid int
Bound int
Bound uint16
}
//Page Binding UI
@ -26,19 +26,14 @@ type Page struct {
//TypeKey event on key
func (bp *Page) TypeKey(e *fyne.KeyEvent) {
bp.Bind.Bound = keys.CKIFyneKeyMap(e.Name)
if keys.CKIFIsCMPLX(e.Name) {
kp := keys.CKICommonName(bp.Bind.Bound)
bp.dev["BL"].(*widget.Label).SetText(kp)
} else {
kp := string(e.Name)
bp.dev["BL"].(*widget.Label).SetText(kp)
}
kp := keys.CKIKeyNameFromASCII(bp.Bind.Bound)
bp.dev["BL"].(*widget.Label).SetText(kp)
}
func (bp *Page) createGrid() *fyne.Container {
cont := fyne.NewContainerWithLayout(layout.NewGridLayoutWithColumns(3))
cont.AddObject(widget.NewButton("Clear", func() {
bp.dev["BL"].(*widget.Label).SetText(keys.CKIName(0))
bp.dev["BL"].(*widget.Label).SetText(keys.CKIKeyNameFromKC(0))
bp.Bind.Bound = 0x0
}))
k1 := widget.NewButton("Tab", func() { bp.TypeKey(&fyne.KeyEvent{Name: fyne.KeyTab}) })
@ -61,18 +56,14 @@ func (bp *Page) createGrid() *fyne.Container {
//Create the binding page popup
func (bp *Page) Create(bid string) fyne.CanvasObject {
bp.dev = make(map[string]fyne.CanvasObject)
if keys.CKIAIsCMPLX(bp.Bind.Bound) {
bp.dev["BL"] = widget.NewLabel(string(keys.ASCIIToCommon[bp.Bind.Bound]))
} else {
bp.dev["BL"] = widget.NewLabel(keys.CKIName(bp.Bind.Bound))
}
bp.dev["BL"] = widget.NewLabel(keys.CKIKeyNameFromASCII(bp.Bind.Bound))
pop := widget.NewVBox(bp.dev["BL"], bp.createGrid())
bp.window.Canvas().SetOnTypedKey(bp.TypeKey)
return pop
}
//NewBindPage Create a new bind popup
func NewBindPage(bid int, w fyne.Window, def int) *Page {
func NewBindPage(bid int, w fyne.Window, def uint16) *Page {
p := &Page{}
p.window = w
p.Bind.Bindid = bid

Loading…
Cancel
Save