Adding modding folder with a hacked build.

modding/hacked/ui/input/StickyKeyBuffer.go

@@ -0,0 +1,101 @@
+package input
+
+// StickyKeyListener is the listener interface for receiving key events.
+type StickyKeyListener interface {
+	// KeyPress is called for a pressed key.
+	KeyPress(key Key, modifier Modifier)
+	// KeyRelease is called for a released key.
+	KeyRelease(key Key, modifier Modifier)
+	// Modifier is called when the currently active modifier changed.
+	Modifier(modifier Modifier)
+}
+
+// StickyKeyBuffer is a buffer to keep track of several identically named keys.
+// Keys can be reported being pressed or released. Their state will be forwarded
+// to a StickyKeyListener instance. If a specific key is reported to be pressed
+// more than once, the listener will have received the down state only once.
+type StickyKeyBuffer struct {
+	pressedKeys     map[Key]int
+	pressedModifier map[Modifier]int
+	activeModifier  Modifier
+	listener        StickyKeyListener
+}
+
+// NewStickyKeyBuffer returns a new instance of a sticky key buffer.
+func NewStickyKeyBuffer(listener StickyKeyListener) *StickyKeyBuffer {
+	buffer := &StickyKeyBuffer{
+		pressedKeys:     make(map[Key]int),
+		pressedModifier: make(map[Modifier]int),
+		activeModifier:  ModNone,
+		listener:        listener,
+	}
+
+	return buffer
+}
+
+// ActiveModifier returns the currently pressed modifier set.
+func (buffer *StickyKeyBuffer) ActiveModifier() Modifier {
+	return buffer.activeModifier
+}
+
+// KeyDown registers a pressed key state. Multiple down states can be
+// registered for the same key and result in only one key event.
+func (buffer *StickyKeyBuffer) KeyDown(key Key, modifier Modifier) {
+	keyAsModifier := key.AsModifier()
+	updatedModifier := modifier.With(keyAsModifier)
+
+	oldCount := buffer.pressedKeys[key]
+	buffer.pressedKeys[key] = oldCount + 1
+	if oldCount == 0 {
+		buffer.listener.KeyPress(key, updatedModifier)
+	}
+
+	buffer.setActiveModifier(updatedModifier)
+	if keyAsModifier != ModNone {
+		buffer.pressedModifier[keyAsModifier]++
+	}
+}
+
+// KeyUp registers a released key state. Multiple up states can be registered
+// for the same key, as long as enough down states were reported.
+func (buffer *StickyKeyBuffer) KeyUp(key Key, modifier Modifier) {
+	updatedModifier := modifier
+	keyAsModifier := key.AsModifier()
+	if keyAsModifier != ModNone {
+		oldCount := buffer.pressedModifier[keyAsModifier]
+		if oldCount > 0 {
+			buffer.pressedModifier[keyAsModifier] = oldCount - 1
+			if oldCount == 1 {
+				updatedModifier = updatedModifier.Without(keyAsModifier)
+			}
+		}
+	}
+
+	oldCount := buffer.pressedKeys[key]
+	if oldCount > 0 {
+		buffer.pressedKeys[key] = oldCount - 1
+		if oldCount == 1 {
+			buffer.listener.KeyRelease(key, updatedModifier)
+		}
+	}
+	buffer.setActiveModifier(updatedModifier)
+}
+
+// ReleaseAll notifies the listener of the reset of all modifiers.
+// Key states are reset to accept new down states.
+func (buffer *StickyKeyBuffer) ReleaseAll() {
+	buffer.pressedKeys = make(map[Key]int)
+	buffer.setActiveModifier(ModNone)
+}
+
+func (buffer *StickyKeyBuffer) setActiveModifier(modifier Modifier) {
+	if buffer.activeModifier != modifier {
+		for mod := range buffer.pressedModifier {
+			if !modifier.Has(mod) {
+				buffer.pressedModifier[mod] = 0
+			}
+		}
+		buffer.activeModifier = modifier
+		buffer.listener.Modifier(buffer.activeModifier)
+	}
+}