Adding modding folder with a hacked build.
This commit is contained in:
ml
@@ -0,0 +1,95 @@
|
||||
package input
|
||||
|
||||
// Key describes a named key on the keyboard. These are keys which are
|
||||
// unspecific to layout or language, or are universal.
|
||||
// Or, described in another way: keys that don't end up as printable characters.
|
||||
type Key int
|
||||
|
||||
// Constants for commonly known named keys.
|
||||
const (
|
||||
KeyEnter = Key(300)
|
||||
KeyEscape = Key(301)
|
||||
KeyBackspace = Key(302)
|
||||
KeyTab = Key(303)
|
||||
|
||||
KeyDown = Key(310)
|
||||
KeyLeft = Key(311)
|
||||
KeyRight = Key(312)
|
||||
KeyUp = Key(313)
|
||||
|
||||
KeyDelete = Key(320)
|
||||
KeyEnd = Key(321)
|
||||
KeyHome = Key(322)
|
||||
KeyInsert = Key(323)
|
||||
KeyPageDown = Key(324)
|
||||
KeyPageUp = Key(325)
|
||||
|
||||
KeyAlt = Key(330)
|
||||
KeyControl = Key(331)
|
||||
KeyShift = Key(332)
|
||||
KeySuper = Key(333)
|
||||
|
||||
KeyPause = Key(340)
|
||||
KeyPrintScreen = Key(341)
|
||||
KeyCapsLock = Key(342)
|
||||
KeyScrollLock = Key(343)
|
||||
|
||||
KeyF1 = Key(351)
|
||||
KeyF10 = Key(360)
|
||||
KeyF11 = Key(361)
|
||||
KeyF12 = Key(362)
|
||||
KeyF13 = Key(363)
|
||||
KeyF14 = Key(364)
|
||||
KeyF15 = Key(365)
|
||||
KeyF16 = Key(366)
|
||||
KeyF17 = Key(367)
|
||||
KeyF18 = Key(368)
|
||||
KeyF19 = Key(369)
|
||||
KeyF2 = Key(352)
|
||||
KeyF20 = Key(370)
|
||||
KeyF21 = Key(371)
|
||||
KeyF22 = Key(372)
|
||||
KeyF23 = Key(373)
|
||||
KeyF24 = Key(374)
|
||||
KeyF25 = Key(375)
|
||||
KeyF3 = Key(353)
|
||||
KeyF4 = Key(354)
|
||||
KeyF5 = Key(355)
|
||||
KeyF6 = Key(356)
|
||||
KeyF7 = Key(357)
|
||||
KeyF8 = Key(358)
|
||||
KeyF9 = Key(359)
|
||||
|
||||
KeyCopy = Key(380)
|
||||
KeyCut = Key(381)
|
||||
KeyPaste = Key(382)
|
||||
|
||||
KeyUndo = Key(390)
|
||||
KeyRedo = Key(391)
|
||||
|
||||
KeySave = Key(400)
|
||||
KeyNew = Key(401)
|
||||
|
||||
KeyA = Key(410)
|
||||
KeyC = Key(411)
|
||||
KeyV = Key(412)
|
||||
KeyX = Key(413)
|
||||
)
|
||||
|
||||
var keyToModifier = map[Key]Modifier{
|
||||
KeyShift: ModShift,
|
||||
KeyControl: ModControl,
|
||||
KeyAlt: ModAlt,
|
||||
KeySuper: ModSuper,
|
||||
}
|
||||
|
||||
// AsModifier returns the modifier equivalent for the key - if applicable.
|
||||
func (key Key) AsModifier() Modifier {
|
||||
mod, isModifier := keyToModifier[key]
|
||||
|
||||
if !isModifier {
|
||||
mod = ModNone
|
||||
}
|
||||
|
||||
return mod
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package input
|
||||
|
||||
// Modifier is a collection of currently pressed modifier keys.
|
||||
type Modifier uint32
|
||||
|
||||
// Constants for common modifier.
|
||||
const (
|
||||
ModNone = Modifier(0x00000000)
|
||||
ModShift = Modifier(0x00000001)
|
||||
ModControl = Modifier(0x00000002)
|
||||
ModAlt = Modifier(0x00000004)
|
||||
ModSuper = Modifier(0x00000008)
|
||||
)
|
||||
|
||||
// IsClear returns true if nothing is set.
|
||||
func (mod Modifier) IsClear() bool {
|
||||
return mod == ModNone
|
||||
}
|
||||
|
||||
// With returns a combination of this modifier and the given one.
|
||||
func (mod Modifier) With(other Modifier) Modifier {
|
||||
return Modifier(uint32(mod) | uint32(other))
|
||||
}
|
||||
|
||||
// Without returns the result of this modifier without the given one.
|
||||
func (mod Modifier) Without(other Modifier) Modifier {
|
||||
return Modifier(uint32(mod) & ^uint32(other))
|
||||
}
|
||||
|
||||
// Has returns true if the given modifier is included in this set.
|
||||
// This modifier can have more keys set than the requested and still return true.
|
||||
func (mod Modifier) Has(other Modifier) bool {
|
||||
return (uint32(mod) | uint32(other)) == uint32(mod)
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package input_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/inkyblackness/hacked/ui/input"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestHasReturnsTrueForThemselves(t *testing.T) {
|
||||
mods := []input.Modifier{input.ModShift, input.ModControl, input.ModAlt, input.ModSuper}
|
||||
|
||||
for _, mod := range mods {
|
||||
assert.True(t, mod.Has(mod))
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasReturnsFalseForDifferentModifiers(t *testing.T) {
|
||||
mods := []input.Modifier{input.ModShift, input.ModControl, input.ModAlt, input.ModSuper}
|
||||
|
||||
for index, mod := range mods {
|
||||
nextMod := mods[(index+1)%len(mods)]
|
||||
assert.False(t, mod.Has(nextMod))
|
||||
}
|
||||
}
|
||||
|
||||
func TestHasReturnsFalseForSetsIncludingOthers(t *testing.T) {
|
||||
mods := []input.Modifier{input.ModShift, input.ModControl, input.ModAlt, input.ModSuper}
|
||||
|
||||
for index, mod := range mods {
|
||||
nextMod := mods[(index+1)%len(mods)]
|
||||
assert.False(t, mod.Has(mod.With(nextMod)))
|
||||
}
|
||||
}
|
||||
|
||||
func TestWithoutReturnsReduction(t *testing.T) {
|
||||
mod := input.ModShift.With(input.ModAlt).Without(input.ModShift)
|
||||
|
||||
assert.Equal(t, input.ModAlt, mod)
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package input
|
||||
|
||||
import "strings"
|
||||
|
||||
type shortcut struct {
|
||||
keyName string
|
||||
modifier Modifier
|
||||
key Key
|
||||
}
|
||||
|
||||
var shortcuts = []shortcut{
|
||||
{keyName: "c", modifier: ModControl, key: KeyCopy},
|
||||
{keyName: "x", modifier: ModControl, key: KeyCut},
|
||||
{keyName: "v", modifier: ModControl, key: KeyPaste},
|
||||
{keyName: "z", modifier: ModControl, key: KeyUndo},
|
||||
{keyName: "z", modifier: ModControl.With(ModShift), key: KeyRedo},
|
||||
{keyName: "y", modifier: ModControl, key: KeyRedo},
|
||||
{keyName: "s", modifier: ModControl, key: KeySave},
|
||||
{keyName: "n", modifier: ModControl, key: KeyNew},
|
||||
}
|
||||
|
||||
// ResolveShortcut tries to map the given name and modifier combination to a
|
||||
// known (common) shortcut key. For instance, Ctrl+C is KeyCopy.
|
||||
func ResolveShortcut(keyName string, modifier Modifier) (key Key, knownKey bool) {
|
||||
lowercaseName := strings.ToLower(keyName)
|
||||
for _, entry := range shortcuts {
|
||||
if (entry.keyName == lowercaseName) && (entry.modifier == modifier) {
|
||||
knownKey = true
|
||||
key = entry.key
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package input_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/inkyblackness/hacked/ui/input"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestResolveShortcutReturnsValuesOfKnownCombo(t *testing.T) {
|
||||
key, knownKey := input.ResolveShortcut("c", input.ModControl)
|
||||
|
||||
assert.True(t, knownKey)
|
||||
assert.Equal(t, input.KeyCopy, key)
|
||||
}
|
||||
|
||||
func TestResolveShortcutReturnsFalseForUnknownCombo(t *testing.T) {
|
||||
_, knownKey := input.ResolveShortcut("l", input.ModControl.With(input.ModShift))
|
||||
|
||||
assert.False(t, knownKey)
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,261 @@
|
||||
package input_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/inkyblackness/hacked/ui/input"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/suite"
|
||||
)
|
||||
|
||||
type keyEvent struct {
|
||||
event string
|
||||
key input.Key
|
||||
mod input.Modifier
|
||||
}
|
||||
|
||||
type testingStickyKeysListener struct {
|
||||
eventMap map[input.Key][]keyEvent
|
||||
events []keyEvent
|
||||
}
|
||||
|
||||
func (listener *testingStickyKeysListener) KeyPress(key input.Key, modifier input.Modifier) {
|
||||
listener.addEvent(keyEvent{event: "P", key: key, mod: modifier})
|
||||
}
|
||||
|
||||
func (listener *testingStickyKeysListener) KeyRelease(key input.Key, modifier input.Modifier) {
|
||||
listener.addEvent(keyEvent{event: "R", key: key, mod: modifier})
|
||||
}
|
||||
|
||||
func (listener *testingStickyKeysListener) Modifier(modifier input.Modifier) {
|
||||
listener.addEvent(keyEvent{event: "M", key: 0, mod: modifier})
|
||||
}
|
||||
|
||||
func (listener *testingStickyKeysListener) addEvent(event keyEvent) {
|
||||
listener.eventMap[event.key] = append(listener.eventMap[event.key], event)
|
||||
listener.events = append(listener.events, event)
|
||||
}
|
||||
|
||||
type StickyKeyBufferSuite struct {
|
||||
suite.Suite
|
||||
buffer *input.StickyKeyBuffer
|
||||
listener *testingStickyKeysListener
|
||||
}
|
||||
|
||||
func TestProviderBackedStoreSuite(t *testing.T) {
|
||||
suite.Run(t, new(StickyKeyBufferSuite))
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) SetupTest() {
|
||||
suite.listener = &testingStickyKeysListener{
|
||||
eventMap: make(map[input.Key][]keyEvent)}
|
||||
suite.buffer = input.NewStickyKeyBuffer(suite.listener)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestRegularEventsAreForwarded_A() {
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF2, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF2, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF1])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF2, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF2, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF2])
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestRegularEventsAreForwarded_B() {
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF2, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF2, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF1])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF2, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF2, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF2])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyF2, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF2, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestIdenticalKeysAreReportedOnlyOnce() {
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF1])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestSuperfluousReleasesAreIgnored() {
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF2, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyF1, input.ModNone)
|
||||
suite.buffer.KeyUp(input.KeyF1, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyF1])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyF2, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyF1, mod: input.ModNone},
|
||||
{event: "R", key: input.KeyF1, mod: input.ModNone},
|
||||
}, suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestReleaseAllResetsRegularKeys() {
|
||||
suite.buffer.KeyDown(input.KeyEnter, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyEnter, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyTab, input.ModNone)
|
||||
suite.buffer.ReleaseAll()
|
||||
suite.buffer.KeyDown(input.KeyTab, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyEnter, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyEnter])
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyTab, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyTab, mod: input.ModNone},
|
||||
}, suite.listener.eventMap[input.KeyTab])
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestModifierEventsAreConvertedToModifierStates_DownAugmented() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModShift)
|
||||
suite.buffer.KeyDown(input.KeyAlt, input.ModShift.With(input.ModAlt))
|
||||
suite.buffer.KeyUp(input.KeyAlt, input.ModShift)
|
||||
suite.buffer.KeyUp(input.KeyShift, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(), 2, len(suite.listener.eventMap[input.KeyShift]))
|
||||
assert.Equal(suite.T(), 2, len(suite.listener.eventMap[input.KeyAlt]))
|
||||
assert.Equal(suite.T(),
|
||||
[]keyEvent{
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "P", key: input.KeyAlt, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "M", key: 0, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "R", key: input.KeyAlt, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "R", key: input.KeyShift, mod: input.ModNone},
|
||||
{event: "M", key: 0, mod: input.ModNone},
|
||||
},
|
||||
suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestModifierEventsAreConvertedToModifierStates_UpAugmented() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyAlt, input.ModShift)
|
||||
suite.buffer.KeyUp(input.KeyAlt, input.ModShift.With(input.ModAlt))
|
||||
suite.buffer.KeyUp(input.KeyShift, input.ModShift)
|
||||
|
||||
assert.Equal(suite.T(), 2, len(suite.listener.eventMap[input.KeyShift]))
|
||||
assert.Equal(suite.T(), 2, len(suite.listener.eventMap[input.KeyAlt]))
|
||||
assert.Equal(suite.T(),
|
||||
[]keyEvent{
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "P", key: input.KeyAlt, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "M", key: 0, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "R", key: input.KeyAlt, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "R", key: input.KeyShift, mod: input.ModNone},
|
||||
{event: "M", key: 0, mod: input.ModNone},
|
||||
},
|
||||
suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestReleaseAllReleasesModifiers() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyAlt, input.ModShift)
|
||||
suite.buffer.ReleaseAll()
|
||||
|
||||
assert.Equal(suite.T(),
|
||||
[]keyEvent{
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "P", key: input.KeyAlt, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "M", key: 0, mod: input.ModShift.With(input.ModAlt)},
|
||||
{event: "M", key: 0, mod: input.ModNone},
|
||||
},
|
||||
suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestActiveModifierReturnsCurrentModifier() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyControl, input.ModShift)
|
||||
suite.buffer.KeyDown(input.KeyAlt, input.ModShift.With(input.ModControl))
|
||||
suite.buffer.KeyUp(input.KeyControl, input.ModShift.With(input.ModControl).With(input.ModAlt))
|
||||
|
||||
assert.Equal(suite.T(), input.ModShift.With(input.ModAlt), suite.buffer.ActiveModifier())
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestModifierAreUpdatedOnOtherKeys_A() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModShift)
|
||||
suite.buffer.KeyDown(input.KeyTab, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(),
|
||||
[]keyEvent{
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "P", key: input.KeyTab, mod: input.ModNone},
|
||||
{event: "M", key: 0, mod: input.ModNone},
|
||||
},
|
||||
suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestModifierAreUpdatedOnOtherKeys_B() {
|
||||
suite.buffer.KeyDown(input.KeyTab, input.ModNone)
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModShift)
|
||||
suite.buffer.KeyUp(input.KeyTab, input.ModNone)
|
||||
|
||||
assert.Equal(suite.T(),
|
||||
[]keyEvent{
|
||||
{event: "P", key: input.KeyTab, mod: input.ModNone},
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
{event: "R", key: input.KeyTab, mod: input.ModNone},
|
||||
{event: "M", key: 0, mod: input.ModNone},
|
||||
},
|
||||
suite.listener.events)
|
||||
}
|
||||
|
||||
func (suite *StickyKeyBufferSuite) TestModifierAreUpdatedOnOtherKeysWithoutThemselves() {
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModShift)
|
||||
suite.buffer.KeyDown(input.KeyShift, input.ModShift)
|
||||
suite.buffer.KeyUp(input.KeyShift, input.ModShift)
|
||||
|
||||
assert.Equal(suite.T(), []keyEvent{
|
||||
{event: "P", key: input.KeyShift, mod: input.ModShift},
|
||||
{event: "M", key: 0, mod: input.ModShift},
|
||||
}, suite.listener.events)
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package input
|
||||
|
||||
const (
|
||||
// MousePrimary specifies the primary mouse button (by default, the left one).
|
||||
MousePrimary = uint32(1)
|
||||
// MouseSecondary specifies the secondary mouse button (by default, the right one).
|
||||
MouseSecondary = uint32(2)
|
||||
)
|
||||
Reference in New Issue
Block a user