433 lines
11 KiB
Go
433 lines
11 KiB
Go
package x
|
|
|
|
import "image"
|
|
|
|
import "github.com/jezek/xgbutil"
|
|
import "github.com/jezek/xgb/xproto"
|
|
import "git.tebibyte.media/tomo/xgbkb"
|
|
import "github.com/jezek/xgbutil/xevent"
|
|
import "git.tebibyte.media/tomo/tomo/input"
|
|
|
|
var buttonCodeTable = map[xproto.Keysym] input.Key {
|
|
0xFFFFFF: input.KeyNone,
|
|
|
|
0xFF63: input.KeyInsert,
|
|
0xFF67: input.KeyMenu,
|
|
0xFF61: input.KeyPrintScreen,
|
|
0xFF6B: input.KeyPause,
|
|
0xFFE5: input.KeyCapsLock,
|
|
0xFF14: input.KeyScrollLock,
|
|
0xFF7F: input.KeyNumLock,
|
|
0xFF08: input.KeyBackspace,
|
|
0xFF09: input.KeyTab,
|
|
0xFE20: input.KeyTab,
|
|
0xFF0D: input.KeyEnter,
|
|
0xFF1B: input.KeyEscape,
|
|
|
|
0xFF52: input.KeyUp,
|
|
0xFF54: input.KeyDown,
|
|
0xFF51: input.KeyLeft,
|
|
0xFF53: input.KeyRight,
|
|
0xFF55: input.KeyPageUp,
|
|
0xFF56: input.KeyPageDown,
|
|
0xFF50: input.KeyHome,
|
|
0xFF57: input.KeyEnd,
|
|
|
|
0xFFE1: input.KeyLeftShift,
|
|
0xFFE2: input.KeyRightShift,
|
|
0xFFE3: input.KeyLeftControl,
|
|
0xFFE4: input.KeyRightControl,
|
|
|
|
0xFFE7: input.KeyLeftMeta,
|
|
0xFFE8: input.KeyRightMeta,
|
|
0xFFE9: input.KeyLeftAlt,
|
|
0xFFEA: input.KeyRightAlt,
|
|
0xFFEB: input.KeyLeftSuper,
|
|
0xFFEC: input.KeyRightSuper,
|
|
0xFFED: input.KeyLeftHyper,
|
|
0xFFEE: input.KeyRightHyper,
|
|
|
|
0xFFFF: input.KeyDelete,
|
|
|
|
0xFFBE: input.KeyF1,
|
|
0xFFBF: input.KeyF2,
|
|
0xFFC0: input.KeyF3,
|
|
0xFFC1: input.KeyF4,
|
|
0xFFC2: input.KeyF5,
|
|
0xFFC3: input.KeyF6,
|
|
0xFFC4: input.KeyF7,
|
|
0xFFC5: input.KeyF8,
|
|
0xFFC6: input.KeyF9,
|
|
0xFFC7: input.KeyF10,
|
|
0xFFC8: input.KeyF11,
|
|
0xFFC9: input.KeyF12,
|
|
|
|
0xFF20: input.KeyDead,
|
|
}
|
|
|
|
var keypadCodeTable = map[xproto.Keysym] input.Key {
|
|
0xff80: input.Key(' '),
|
|
0xff89: input.KeyTab,
|
|
0xff8d: input.KeyEnter,
|
|
0xff91: input.KeyF1,
|
|
0xff92: input.KeyF2,
|
|
0xff93: input.KeyF3,
|
|
0xff94: input.KeyF4,
|
|
0xff95: input.KeyHome,
|
|
0xff96: input.KeyLeft,
|
|
0xff97: input.KeyUp,
|
|
0xff98: input.KeyRight,
|
|
0xff99: input.KeyDown,
|
|
0xff9a: input.KeyPageUp,
|
|
0xff9b: input.KeyPageDown,
|
|
0xff9c: input.KeyEnd,
|
|
0xff9d: input.KeyHome,
|
|
0xff9e: input.KeyInsert,
|
|
0xff9f: input.KeyDelete,
|
|
0xffbd: input.Key('='),
|
|
0xffaa: input.Key('*'),
|
|
0xffab: input.Key('+'),
|
|
0xffac: input.Key(','),
|
|
0xffad: input.Key('-'),
|
|
0xffae: input.Key('.'),
|
|
0xffaf: input.Key('/'),
|
|
|
|
0xffb0: input.Key('0'),
|
|
0xffb1: input.Key('1'),
|
|
0xffb2: input.Key('2'),
|
|
0xffb3: input.Key('3'),
|
|
0xffb4: input.Key('4'),
|
|
0xffb5: input.Key('5'),
|
|
0xffb6: input.Key('6'),
|
|
0xffb7: input.Key('7'),
|
|
0xffb8: input.Key('8'),
|
|
0xffb9: input.Key('9'),
|
|
}
|
|
|
|
func (window *window) handleExpose (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.ExposeEvent,
|
|
) {
|
|
if window.xCanvas == nil {
|
|
window.reallocateCanvas()
|
|
}
|
|
window.compressExpose(*event.ExposeEvent)
|
|
window.pushAll()
|
|
}
|
|
|
|
func (window *window) updateBounds () {
|
|
// FIXME: some window managers parent windows more than once, we might
|
|
// need to sum up all their positions.
|
|
decorGeometry, _ := window.xWindow.DecorGeometry()
|
|
windowGeometry, _ := window.xWindow.Geometry()
|
|
origin := image.Pt(
|
|
windowGeometry.X() + decorGeometry.X(),
|
|
windowGeometry.Y() + decorGeometry.Y())
|
|
window.metrics.bounds = image.Rectangle {
|
|
Min: origin,
|
|
Max: origin.Add(image.Pt(windowGeometry.Width(), windowGeometry.Height())),
|
|
}
|
|
}
|
|
|
|
func (window *window) handleConfigureNotify (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.ConfigureNotifyEvent,
|
|
) {
|
|
if window.root == nil { return }
|
|
|
|
configureEvent := *event.ConfigureNotifyEvent
|
|
|
|
newWidth := int(configureEvent.Width)
|
|
newHeight := int(configureEvent.Height)
|
|
sizeChanged :=
|
|
window.metrics.bounds.Dx() != newWidth ||
|
|
window.metrics.bounds.Dy() != newHeight
|
|
window.updateBounds()
|
|
|
|
if sizeChanged {
|
|
configureEvent = window.compressConfigureNotify(configureEvent)
|
|
window.reallocateCanvas()
|
|
|
|
// TODO figure out what to do with this
|
|
// if !window.exposeEventFollows(configureEvent) {
|
|
// }
|
|
}
|
|
}
|
|
|
|
func (window *window) exposeEventFollows (event xproto.ConfigureNotifyEvent) (found bool) {
|
|
nextEvents := xevent.Peek(window.backend.x)
|
|
if len(nextEvents) > 0 {
|
|
untypedEvent := nextEvents[0]
|
|
if untypedEvent.Err == nil {
|
|
typedEvent, ok :=
|
|
untypedEvent.Event.(xproto.ConfigureNotifyEvent)
|
|
|
|
if ok && typedEvent.Window == event.Window {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func keycodeToKey (keycode xproto.Keycode, state uint16) (input.Key, bool) {
|
|
keysym, char := xgbkb.KeycodeToKeysym(keycode, state)
|
|
|
|
if xgbkb.IsOnNumpad(keysym) {
|
|
// look up in keypad table
|
|
key := keypadCodeTable[keysym]
|
|
return key, true
|
|
} else {
|
|
// look up in control code table
|
|
key, isControl := buttonCodeTable[keysym]
|
|
if isControl {
|
|
return key, false
|
|
} else {
|
|
// return as rune
|
|
return input.Key(char), false
|
|
}
|
|
}
|
|
}
|
|
|
|
func (window *window) handleKeyPress (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.KeyPressEvent,
|
|
) {
|
|
if window.hasModal { return }
|
|
|
|
keyEvent := *event.KeyPressEvent
|
|
key, numberPad := keycodeToKey(keyEvent.Detail, keyEvent.State)
|
|
window.updateModifiers(keyEvent.State)
|
|
|
|
if key == input.KeyTab && window.modifiers.Alt {
|
|
if window.modifiers.Shift {
|
|
window.focusPrevious()
|
|
} else {
|
|
window.focusNext()
|
|
}
|
|
} else if key == input.KeyEscape && window.shy {
|
|
window.Close()
|
|
} else if window.focused != nil {
|
|
window.focused.handleKeyDown(key, numberPad)
|
|
}
|
|
}
|
|
|
|
func (window *window) handleKeyRelease (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.KeyReleaseEvent,
|
|
) {
|
|
if window.hasModal { return }
|
|
|
|
keyEvent := *event.KeyReleaseEvent
|
|
|
|
// do not process this event if it was generated from a key repeat
|
|
nextEvents := xevent.Peek(window.backend.x)
|
|
if len(nextEvents) > 0 {
|
|
untypedEvent := nextEvents[0]
|
|
if untypedEvent.Err == nil {
|
|
typedEvent, ok :=
|
|
untypedEvent.Event.(xproto.KeyPressEvent)
|
|
|
|
if ok && typedEvent.Detail == keyEvent.Detail &&
|
|
typedEvent.Event == keyEvent.Event &&
|
|
typedEvent.State == keyEvent.State {
|
|
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
key, numberPad := keycodeToKey(keyEvent.Detail, keyEvent.State)
|
|
window.updateModifiers(keyEvent.State)
|
|
|
|
if window.focused != nil {
|
|
window.focused.handleKeyUp(key, numberPad)
|
|
}
|
|
}
|
|
|
|
func (window *window) handleButtonPress (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.ButtonPressEvent,
|
|
) {
|
|
if window.hasModal { return }
|
|
|
|
buttonEvent := *event.ButtonPressEvent
|
|
point := image.Pt(int(buttonEvent.EventX), int(buttonEvent.EventY))
|
|
insideWindow := point.In(window.xCanvas.Bounds())
|
|
scrolling := buttonEvent.Detail >= 4 && buttonEvent.Detail <= 7
|
|
window.updateModifiers(buttonEvent.State)
|
|
window.updateMousePosition(buttonEvent.EventX, buttonEvent.EventY)
|
|
|
|
if !insideWindow && window.shy && !scrolling {
|
|
window.Close()
|
|
} else if scrolling {
|
|
// TODO
|
|
// underneath := window.scrollTargetChildAt(point)
|
|
// if underneath != nil {
|
|
// if child, ok := underneath.element.(ability.ScrollTarget); ok {
|
|
// sum := scrollSum { }
|
|
// sum.add(buttonEvent.Detail, window, buttonEvent.State)
|
|
// window.compressScrollSum(buttonEvent, &sum)
|
|
// child.HandleScroll (
|
|
// point, float64(sum.x), float64(sum.y),
|
|
// modifiers)
|
|
// }
|
|
// }
|
|
} else {
|
|
underneath := window.boxUnder(point)
|
|
window.drags[buttonEvent.Detail] = underneath
|
|
if underneath != nil {
|
|
underneath.handleMouseDown(input.Button(buttonEvent.Detail))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (window *window) handleButtonRelease (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.ButtonReleaseEvent,
|
|
) {
|
|
if window.hasModal { return }
|
|
|
|
buttonEvent := *event.ButtonReleaseEvent
|
|
if buttonEvent.Detail >= 4 && buttonEvent.Detail <= 7 { return }
|
|
window.updateModifiers(buttonEvent.State)
|
|
window.updateMousePosition(buttonEvent.EventX, buttonEvent.EventY)
|
|
dragging := window.drags[buttonEvent.Detail]
|
|
window.drags[buttonEvent.Detail] = nil
|
|
|
|
if dragging != nil {
|
|
dragging.handleMouseUp(input.Button(buttonEvent.Detail))
|
|
}
|
|
}
|
|
|
|
func (window *window) handleMotionNotify (
|
|
connection *xgbutil.XUtil,
|
|
event xevent.MotionNotifyEvent,
|
|
) {
|
|
if window.hasModal { return }
|
|
|
|
motionEvent := window.compressMotionNotify(*event.MotionNotifyEvent)
|
|
window.updateMousePosition(motionEvent.EventX, motionEvent.EventY)
|
|
x := int(motionEvent.EventX)
|
|
y := int(motionEvent.EventY)
|
|
|
|
handled := false
|
|
for _, child := range window.drags {
|
|
if child == nil { continue }
|
|
child.handleMouseMove()
|
|
window.hover(child)
|
|
handled = true
|
|
}
|
|
|
|
if !handled {
|
|
underneath := window.boxUnder(image.Pt(x, y))
|
|
underneath.handleMouseMove()
|
|
window.hover(underneath)
|
|
}
|
|
}
|
|
|
|
func (window *window) compressExpose (
|
|
firstEvent xproto.ExposeEvent,
|
|
) (
|
|
lastEvent xproto.ExposeEvent,
|
|
region image.Rectangle,
|
|
) {
|
|
region = image.Rect (
|
|
int(firstEvent.X), int(firstEvent.Y),
|
|
int(firstEvent.X + firstEvent.Width),
|
|
int(firstEvent.Y + firstEvent.Height))
|
|
|
|
window.backend.x.Sync()
|
|
xevent.Read(window.backend.x, false)
|
|
lastEvent = firstEvent
|
|
|
|
for index, untypedEvent := range xevent.Peek(window.backend.x) {
|
|
if untypedEvent.Err != nil { continue }
|
|
|
|
typedEvent, ok := untypedEvent.Event.(xproto.ExposeEvent)
|
|
if !ok { continue }
|
|
|
|
if firstEvent.Window == typedEvent.Window {
|
|
region = region.Union (image.Rect (
|
|
int(typedEvent.X), int(typedEvent.Y),
|
|
int(typedEvent.X + typedEvent.Width),
|
|
int(typedEvent.Y + typedEvent.Height)))
|
|
|
|
lastEvent = typedEvent
|
|
defer func (index int) {
|
|
xevent.DequeueAt(window.backend.x, index)
|
|
} (index)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (window *window) compressConfigureNotify (
|
|
firstEvent xproto.ConfigureNotifyEvent,
|
|
) (
|
|
lastEvent xproto.ConfigureNotifyEvent,
|
|
) {
|
|
window.backend.x.Sync()
|
|
xevent.Read(window.backend.x, false)
|
|
lastEvent = firstEvent
|
|
|
|
for index, untypedEvent := range xevent.Peek(window.backend.x) {
|
|
if untypedEvent.Err != nil { continue }
|
|
|
|
typedEvent, ok := untypedEvent.Event.(xproto.ConfigureNotifyEvent)
|
|
if !ok { continue }
|
|
|
|
if firstEvent.Event == typedEvent.Event &&
|
|
firstEvent.Window == typedEvent.Window {
|
|
|
|
lastEvent = typedEvent
|
|
defer func (index int) {
|
|
xevent.DequeueAt(window.backend.x, index)
|
|
} (index)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (window *window) compressMotionNotify (
|
|
firstEvent xproto.MotionNotifyEvent,
|
|
) (
|
|
lastEvent xproto.MotionNotifyEvent,
|
|
) {
|
|
window.backend.x.Sync()
|
|
xevent.Read(window.backend.x, false)
|
|
lastEvent = firstEvent
|
|
|
|
for index, untypedEvent := range xevent.Peek(window.backend.x) {
|
|
if untypedEvent.Err != nil { continue }
|
|
|
|
typedEvent, ok := untypedEvent.Event.(xproto.MotionNotifyEvent)
|
|
if !ok { continue }
|
|
|
|
if firstEvent.Event == typedEvent.Event {
|
|
lastEvent = typedEvent
|
|
defer func (index int) {
|
|
xevent.DequeueAt(window.backend.x, index)
|
|
} (index)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (window *window) updateModifiers (state uint16) {
|
|
modifiers := xgbkb.StateToModifiers(state)
|
|
window.modifiers.Shift = modifiers.Shift || modifiers.ShiftLock
|
|
window.modifiers.Control = modifiers.Control
|
|
window.modifiers.Alt = modifiers.Alt
|
|
window.modifiers.Meta = modifiers.Meta
|
|
window.modifiers.Super = modifiers.Super
|
|
window.modifiers.Hyper = modifiers.Hyper
|
|
}
|
|
|
|
func (window *window) updateMousePosition (x, y int16) {
|
|
window.mousePosition = image.Pt(int(x), int(y))
|
|
}
|