neko/internal/desktop/xorg/xorg.go

320 lines
5.7 KiB
Go
Raw Normal View History

package xorg
/*
2021-01-12 03:57:14 +13:00
#cgo linux LDFLAGS: -lX11 -lXrandr -lXtst -lXfixes
#include "xorg.h"
*/
import "C"
import (
"fmt"
"sync"
"time"
"unsafe"
2021-01-22 08:44:09 +13:00
"image"
"image/color"
2020-10-29 07:15:48 +13:00
"demodesk/neko/internal/types"
)
2021-01-13 11:35:11 +13:00
type KbdModifiers uint8
2021-01-13 10:54:13 +13:00
const (
KBD_CAPS_LOCK KbdModifiers = 2
KBD_NUM_LOCK KbdModifiers = 16
)
var ScreenConfigurations = make(map[int]types.ScreenConfiguration)
2021-02-24 09:25:55 +13:00
var debounce_button = make(map[uint32]time.Time)
var debounce_key = make(map[uint32]time.Time)
var mu = sync.Mutex{}
2020-11-04 12:09:52 +13:00
func GetScreenConfigurations() {
2020-11-15 10:35:50 +13:00
mu.Lock()
defer mu.Unlock()
C.XGetScreenConfigurations()
}
2021-03-12 05:44:49 +13:00
func DisplayOpen(display string) bool {
mu.Lock()
defer mu.Unlock()
displayUnsafe := C.CString(display)
defer C.free(unsafe.Pointer(displayUnsafe))
2021-03-12 05:44:49 +13:00
ok := C.XDisplayOpen(displayUnsafe)
return int(ok) == 1
2020-11-04 12:09:52 +13:00
}
func DisplayClose() {
mu.Lock()
defer mu.Unlock()
2021-02-03 06:28:32 +13:00
2020-11-04 12:09:52 +13:00
C.XDisplayClose()
}
func Move(x, y int) {
mu.Lock()
defer mu.Unlock()
C.XMove(C.int(x), C.int(y))
}
2021-02-18 09:55:11 +13:00
func GetCursorPosition() (int, int) {
mu.Lock()
defer mu.Unlock()
var x C.int
var y C.int
C.XCursorPosition(&x, &y)
2021-02-21 12:41:04 +13:00
2021-02-18 09:55:11 +13:00
return int(x), int(y)
}
func Scroll(x, y int) {
mu.Lock()
defer mu.Unlock()
C.XScroll(C.int(x), C.int(y))
}
2021-02-24 09:25:55 +13:00
func ButtonDown(code uint32) error {
mu.Lock()
defer mu.Unlock()
if _, ok := debounce_button[code]; ok {
return fmt.Errorf("debounced button %v", code)
}
debounce_button[code] = time.Now()
C.XButton(C.uint(code), C.int(1))
return nil
}
2021-02-24 09:25:55 +13:00
func KeyDown(code uint32) error {
mu.Lock()
defer mu.Unlock()
if _, ok := debounce_key[code]; ok {
return fmt.Errorf("debounced key %v", code)
}
debounce_key[code] = time.Now()
2021-04-10 11:10:14 +12:00
C.XKey(C.KeySym(code), C.int(1))
return nil
}
2021-02-24 09:25:55 +13:00
func ButtonUp(code uint32) error {
mu.Lock()
defer mu.Unlock()
if _, ok := debounce_button[code]; !ok {
return fmt.Errorf("debounced button %v", code)
}
delete(debounce_button, code)
C.XButton(C.uint(code), C.int(0))
return nil
}
2021-02-24 09:25:55 +13:00
func KeyUp(code uint32) error {
mu.Lock()
defer mu.Unlock()
if _, ok := debounce_key[code]; !ok {
return fmt.Errorf("debounced key %v", code)
}
delete(debounce_key, code)
2021-04-10 11:10:14 +12:00
C.XKey(C.KeySym(code), C.int(0))
return nil
}
func ResetKeys() {
2020-11-15 10:35:50 +13:00
mu.Lock()
defer mu.Unlock()
2020-11-15 10:35:50 +13:00
for code := range debounce_button {
C.XButton(C.uint(code), C.int(0))
delete(debounce_button, code)
}
2020-11-15 10:35:50 +13:00
for code := range debounce_key {
2021-04-10 11:10:14 +12:00
C.XKey(C.KeySym(code), C.int(0))
delete(debounce_key, code)
}
}
func CheckKeys(duration time.Duration) {
2020-11-15 10:35:50 +13:00
mu.Lock()
defer mu.Unlock()
t := time.Now()
for code, start := range debounce_button {
if t.Sub(start) < duration {
continue
}
2020-11-15 10:35:50 +13:00
C.XButton(C.uint(code), C.int(0))
delete(debounce_button, code)
}
2020-11-15 10:35:50 +13:00
for code, start := range debounce_key {
if t.Sub(start) < duration {
continue
}
2021-04-10 11:10:14 +12:00
C.XKey(C.KeySym(code), C.int(0))
delete(debounce_key, code)
}
}
2021-01-16 05:30:19 +13:00
func ChangeScreenSize(width int, height int, rate int16) error {
mu.Lock()
defer mu.Unlock()
for index, size := range ScreenConfigurations {
if size.Width == width && size.Height == height {
for _, fps := range size.Rates {
2021-01-16 05:30:19 +13:00
if rate == fps {
C.XSetScreenConfiguration(C.int(index), C.short(fps))
return nil
}
}
}
}
2021-04-25 07:37:43 +12:00
return fmt.Errorf("unknown screen configuration %dx%d@%d", width, height, rate)
}
func GetScreenSize() *types.ScreenSize {
mu.Lock()
defer mu.Unlock()
index := int(C.XGetScreenSize())
rate := int16(C.XGetScreenRate())
if conf, ok := ScreenConfigurations[index]; ok {
return &types.ScreenSize{
Width: conf.Width,
Height: conf.Height,
Rate: rate,
}
}
return nil
}
2021-01-13 10:54:13 +13:00
func SetKeyboardModifier(mod KbdModifiers, active bool) {
mu.Lock()
defer mu.Unlock()
num := C.int(0)
if active {
num = C.int(1)
}
C.XSetKeyboardModifier(C.int(mod), num)
}
2021-01-13 11:35:11 +13:00
func GetKeyboardModifiers() KbdModifiers {
mu.Lock()
defer mu.Unlock()
2021-01-13 11:35:11 +13:00
return KbdModifiers(C.XGetKeyboardModifiers())
}
2021-01-10 10:58:18 +13:00
func GetCursorImage() *types.CursorImage {
mu.Lock()
defer mu.Unlock()
2021-01-26 05:31:24 +13:00
cur := C.XGetCursorImage()
2021-01-10 10:58:18 +13:00
defer C.XFree(unsafe.Pointer(cur))
width := int(cur.width)
height := int(cur.height)
// Xlib stores 32-bit data in longs, even if longs are 64-bits long.
pixels := C.GoBytes(unsafe.Pointer(cur.pixels), C.int(width*height*8))
img := image.NewRGBA(image.Rect(0, 0, width, height))
2021-03-25 23:59:57 +13:00
for y := 0; y < height; y++ {
for x := 0; x < width; x++ {
pos := ((y * width) + x) * 8
2021-03-25 23:59:57 +13:00
img.SetRGBA(x, y, color.RGBA{
A: pixels[pos+3],
R: pixels[pos+2],
G: pixels[pos+1],
B: pixels[pos+0],
})
}
}
2021-01-10 10:58:18 +13:00
return &types.CursorImage{
Width: uint16(width),
Height: uint16(height),
2021-02-15 02:40:17 +13:00
Xhot: uint16(cur.xhot),
Yhot: uint16(cur.yhot),
2021-01-10 10:58:18 +13:00
Serial: uint64(cur.cursor_serial),
Image: img,
2021-01-10 10:58:18 +13:00
}
}
2021-01-22 08:44:09 +13:00
func GetScreenshotImage() *image.RGBA {
mu.Lock()
defer mu.Unlock()
var w, h C.int
pixelsUnsafe := C.XGetScreenshot(&w, &h)
2021-02-15 02:40:17 +13:00
pixels := C.GoBytes(unsafe.Pointer(pixelsUnsafe), w*h*3)
2021-01-22 08:44:09 +13:00
defer C.free(unsafe.Pointer(pixelsUnsafe))
width := int(w)
height := int(h)
img := image.NewRGBA(image.Rect(0, 0, width, height))
for row := 0; row < height; row++ {
for col := 0; col < width; col++ {
pos := ((row * width) + col) * 3
img.SetRGBA(col, row, color.RGBA{
R: uint8(pixels[pos]),
G: uint8(pixels[pos+1]),
B: uint8(pixels[pos+2]),
A: 0xFF,
})
}
}
return img
}
//export goCreateScreenSize
func goCreateScreenSize(index C.int, width C.int, height C.int, mwidth C.int, mheight C.int) {
ScreenConfigurations[int(index)] = types.ScreenConfiguration{
Width: int(width),
Height: int(height),
Rates: make(map[int]int16),
}
}
//export goSetScreenRates
func goSetScreenRates(index C.int, rate_index C.int, rateC C.short) {
rate := int16(rateC)
// filter out all irrelevant rates
2021-02-15 02:40:17 +13:00
if rate > 60 || (rate > 30 && rate%10 != 0) {
return
}
ScreenConfigurations[int(index)].Rates[int(rate_index)] = rate
}