Nice keyboard inputs in Elm.
Install with
elm install ohanhi/keyboard
You can use this package in two ways:
- The "Msg and Update" way, which has some setting up to do but has a bunch of ways to help you get the information you need.
- The "Plain Subscriptions" way, where you get subscriptions for keys' down and up events, and handle the rest on your own.
All of the examples are in the example
directory in the repository.
If you use the "Msg and Update" way, you will get the most help, such as:
- All keyboard keys are named values of the
Key
type, such asArrowUp
,Character "A"
andEnter
- You can find out whether e.g.
Shift
is pressed down when any kind of aMsg
happens in your program - Arrow keys and WASD can be used as
{ x : Int, y : Int }
or as a union type (e.g.South
,NorthEast
) - You can also get a full list of keys that are pressed down
When using Keyboard like this, it follows The Elm Architecture. Its model is a list of keys, and it has an update
function and some subscriptions
. Below are the necessary parts to wire things up. Once that is done, you can use the list of keys in your program as you like. You can also get useful information using the helper functions such as arrows
and arrowsDirection
.
Include the list of keys in your program's model
import Keyboard exposing (Key(..))
import Keyboard.Arrows
type alias Model =
{ pressedKeys : List Key
-- ...
}
init : ( Model, Cmd Msg )
init =
( { pressedKeys = []
-- ...
}
, Cmd.none
)
Add the message type in your messages
type Msg
= KeyMsg Keyboard.Msg
-- ...
Include the subscriptions for the events to come through (remember to add them in your main
too)
subscriptions : Model -> Sub Msg
subscriptions model =
Sub.batch
[ Sub.map KeyMsg Keyboard.subscriptions
-- ...
]
And finally, you can use update
to have the list of keys be up to date
update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
case msg of
KeyMsg keyMsg ->
( { model | pressedKeys = Keyboard.update keyMsg model.pressedKeys }
, Cmd.none
)
-- ...
Now you can get all the information anywhere where you have access to the model, for example like so:
calculateSpeed : Model -> Float
calculateSpeed model =
let
arrows =
Keyboard.Arrows.arrows model.pressedKeys
in
model.currentSpeed + arrows.x
isShooting : Model -> Bool
isShooting model =
List.member Spacebar model.pressedKeys
Have fun! :)
PS. The Tracking Key Changes example example shows how to use updateWithKeyChange
to find out exactly which key was pressed down / released on that update cycle.
With the "plain subscriptions" way, you get the bare minimum:
- All keyboard keys are named values of the
Key
type, such asArrowUp
,Character "A"
andEnter
Setting up is very straight-forward:
import Keyboard exposing (RawKey)
type Msg
= KeyDown RawKey
| KeyUp RawKey
| ClearKeys
-- ...
subscriptions : Model -> Sub Msg
subscriptions model =
Sub.batch
[ Keyboard.downs KeyDown
, Keyboard.ups KeyUp
, Keyboard.clears ClearKeys
-- ...
]
Note that you will probably want to use one of the KeyParser
s (or many with oneOf
) in your update.
There's an example for this, too: Plain Subscriptions