[Question]
  [
(The word frame in the following text does not mean an actual frame, it is used as a placeholder for an undefined time unit)
# The task
Imagine you have a keyboard layout with only letters like so:
```
q w e r t y u i o p
 a s d f g h j k l
  z x c v b n m
```
Whenever you press a key, for example `f`, the keyboard lights up the keys around it each frame like this (unordered, each line is a separate frame):
```
F
RTGVCD
YHBXSE
UJNWAZ
IKMQ
OL
P
```
As you can see, each frame lights up the keys around the ones that were lit previously, but not the ones that have already been lit up before.
After you have determined which keys need to be pressed each frame, you need to visualize them. For each frame, you print out the default keyboard layout (with all of the whitespace), but with the lit up keys uppercased. In our example:
```
q w e r t y u i o p
 a s d F g h j k l
  z x c v b n m
q w e R T y u i o p
 a s D f G h j k l
  z x C V b n m
q w E r t Y u i o p
 a S d f g H j k l
  z X c v B n m
q W e r t y U i o p
 A s d f g h J k l
  Z x c v b N m
Q w e r t y u I o p
 a s d f g h j K l
  z x c v b n M
q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m
q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m
```
# Rules
1. Input will be a single letter, you can choose whether it will be capitalized or not.
2. Output can be either:
a. An array of multiline strings representing each second of the visualized keyboard
b. A single multiline string with each frame of the visualized keyboard separated by at least one newline
3. You can output a trailing newline or/and the final keyboard visualization when no keys are lit anymore
# Test cases
```
Input: F
Output:
q w e r t y u i o p
 a s d F g h j k l
  z x c v b n m
q w e R T y u i o p
 a s D f G h j k l
  z x C V b n m
q w E r t Y u i o p
 a S d f g H j k l
  z X c v B n m
q W e r t y U i o p
 A s d f g h J k l
  Z x c v b N m
Q w e r t y u I o p
 a s d f g h j K l
  z x c v b n M
q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m
q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m
Input: Q
Output:
Q w e r t y u i o p
 a s d f g h j k l
  z x c v b n m
q W e r t y u i o p
 A s d f g h j k l
  z x c v b n m
q w E r t y u i o p
 a S d f g h j k l
  Z x c v b n m
q w e R t y u i o p
 a s D f g h j k l
  z X c v b n m
q w e r T y u i o p
 a s d F g h j k l
  z x C v b n m
q w e r t Y u i o p
 a s d f G h j k l
  z x c V b n m
q w e r t y U i o p
 a s d f g H j k l
  z x c v B n m
q w e r t y u I o p
 a s d f g h J k l
  z x c v b N m
q w e r t y u i O p
 a s d f g h j K l
  z x c v b n M
q w e r t y u i o P
 a s d f g h j k L
  z x c v b n m
Input: Z
Output:
q w e r t y u i o p
 a s d f g h j k l
  Z x c v b n m
q w e r t y u i o p
 A S d f g h j k l
  z X c v b n m
Q W E r t y u i o p
 a s D f g h j k l
  z x C v b n m
q w e R t y u i o p
 a s d F g h j k l
  z x c V b n m
q w e r T y u i o p
 a s d f G h j k l
  z x c v B n m
q w e r t Y u i o p
 a s d f g H j k l
  z x c v b N m
q w e r t y U i o p
 a s d f g h J k l
  z x c v b n M
q w e r t y u I o p
 a s d f g h j K l
  z x c v b n m
q w e r t y u i O p
 a s d f g h j k L
  z x c v b n m
q w e r t y u i o P
 a s d f g h j k l
  z x c v b n m
```
  
[Answer]
# [Haskell](https://www.haskell.org/), 229 bytes
```
e=zip[0..]
x!y=abs$x-y
k=e["Q W E R T Y U I O P"," A S D F G H J K L","  Z X C V B N M"]
f c=filter(any(<"a").words)[unlines[[[z..]!!sum[32|z>'@',max(2*y!i)(y!i+x!j)/=d*2]|(x,z)<-e m]|(y,m)<-k]|(i,l)<-k,(j,h)<-e l,c==h,d<-[0..9]]
```
[Try it online!](https://tio.run/##JY9ZT4NAAITf@RUDaQLUBQ0@mbDGs16tVz27IWblkC0LJRwRSH@7CPoy@WbmYTIxL5NQyr4PaSdytmfbntKoLeWf5aSxWiWhIdMe8IpzPOIJ73jGFe5wrxENx1jiDDNc4BLXuMF8DLHCG07xghPcYqF5SgSfRkJWYWHwrDVcjWum/b0pgtJkdSZFFpaMsW4YVtWyTtm@s@0O9SOdpLwxnGmrCtMYZKdR1@YuDaaOtzUa0pmuFSIduCXpwMlAgsiRiLEm8V8tiU9pTALXGo8deF6fcpGBItgoQF6IrMIEEfSZPviU54sP5HW1rIp59l@sdKX/8SPJv8re8vP8Fw "Haskell – Try It Online")
`f` takes an uppercase char argument and returns a list of multiline strings.
It loops over the keyboard layout looking for `(i,j)`, the position of the given character. When it finds it, for each `d<-[0..9]` it generates a string (`unlines[…]`) of the keyboard with all letters *not* `d` hex-steps away lowercased. It never takes longer than 10 steps for the wave to leave the keyboard, so this is OK. Finally, strings that don't contain any uppercase letters are filtered away from the result.
I calculate the hex distance between two points on the keyboard as: \$ \max\left(2|y\_1-y\_2|, |x\_1-x\_2|+|y\_1-y\_2|\right)\$. Here are some distances around a point under this metric:
```
   6666666                                 6 6 6 6
  654444456                               6 4 4 4 6
 65432223456                             6 4 2 2 4 6
6543210123456  --> on staggered grid:   6 4 2 0 2 4 6
 65432223456                             6 4 2 2 4 6
  654444456                               6 4 4 4 6
   6666666                                 6 6 6 6
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 82 bytes
```
≔⪪”&±=Ｋ≕⦃Vj@η⟲.w\`o:7➙1”¶υ≔⊟Φυ№ιθηΦＥχＥυ⁺× μ⪫⭆λ⎇⁼ι⌈↔⊟Ｅ⟦⟦⁻μ⌕υη⁻ξ⌕ηθ⟧⟧⊞ＯπΣπ↥νν ⊙ι⊙λ№αν
```
[Try it online!](https://tio.run/##NY@9bsMwDIT3PoXgiQZUoJ0zGUUzFDBqIOkUZ1AcNVIqU7J@Ujsv71KOy4XQ8Xj81CnhOyvMPFch6AvCzhkdoRh@pY9T0ta1KML5@6KuP6bF@9jdTtgXnBUtFiVnqdw8rZuNdbDVJkoPibM3mzCC5mwoS/Ip8jVek7RaauHg9YWz3MnemBRgr3sZoGAU39POh9XEE2nrkl2Gs730KPwE70MSJuT0Woy6Tz1Up2BNinKhyO7DodZImT1nW43nfENlkIc6rqpa@I5HAkhBfTrpRbQeHGc7CnXlUpx9OZp0IkhAemGWiPIxq3DKILmZ/2@LxUS1mef7/Hwzfw "Charcoal – Try It Online") Link is to verbose version of code. Takes input in lower case. Explanation:
```
≔⪪”&±=Ｋ≕⦃Vj@η⟲.w\`o:7➙1”¶υ
```
Get the list `qwertyuiop`, `asdfghjkl`, `zxcvbnm` by splitting a compressed string.
```
≔⊟Φυ№ιθη
```
Find the element of the above list that contains the input.
```
Ｅχ
```
Create a list of lists corresponding to each step away from the input on the staggered grid from 0 to 9.
```
Ｅυ⁺× μ⪫⭆λ⎇⁼ι⌈↔⊟Ｅ⟦⟦⁻μ⌕υη⁻ξ⌕ηθ⟧⟧⊞ＯπΣπ↥νν 
```
Uppercase the letters that are the desired distance from the input on the staggered grid, then stagger the result by prefixing each line with an increasing number of spaces and double-spacing the letters.
```
Φ...⊙ι⊙λ№αν
```
Only print those lists that contain an uppercase letter.
The formula I'm using for distance is the maximum of \$|x\_2-x\_1|\$, \$|y\_2-y\_1|\$ and \$|x\_2-x\_1+y\_2-y\_1|\$ their sum, where \$y\$ is the (0-indexed) row counting down and \$x\$ is the (skewed) column:
```
0 1 2 3 4 5 6 7 8 9
 0 1 2 3 4 5 6 7 8
  0 1 2 3 4 5 6
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~59~~ ~~57~~ 50 bytes
Thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen) for -3 bytes!
Input is in lowercase, the program prints the keyboards separated by empty lines. Outputs the final dark keyboard for some keys.
Uses the distance metric from [Lynn's answer](https://codegolf.stackexchange.com/a/214288/64121).
```
žVðæ.ιSðý©Ik19‰¸Þ2Ý18Ýâαε¬sO;‚à}>ZFD®sÅÏu}19ô»,¶?<
```
[Try it online!](https://tio.run/##AVcAqP9vc2FiaWX//8W@VsOww6YuzrlTw7DDvcKpSWsxOeKAsMK4w54yw50xOMOdw6LOsc61wqxzTzvigJrDoH0@WkZEwq5zw4XDj3V9MTnDtMK7LMK2Pzz//3E "05AB1E – Try It Online")
**Commented**:
```
                 # keyboard creation
žV               # push ["qwertyuiop", "asdfghjkl", "zxcvbnm"]
  ð              # push a space
   æ             # push the powerset ["", " "]
    .ι           # interleave both lists
      S          # split into a list of characters
       δý        # join with spaces
         ©       # store this value in the register
I                # push the input
 k               # the index of the input in the keyboard string
  19‰            # divmod by 19 to get [y, x]-coordinates
     ¸Þ          # cycle this value forever
       2Ý        # push [0..2]
         18Ý     # push [0..18]
            â    # cartesian product to get a list of all coordinates
             α   # take the element-wise difference [dy, dx] for each coord
                 # apply distance metric
ε      }         # map over the absolute differences:
 ¬               #   get the first element dy
  s              #   swap back to [dy, dx]
   O             #   sum it
    ;            #   halve it
     ‚           #   pair into a list [dy, (dy+dx)/2]          
      à          #   take the maximum
        >        # increment every value
                 # so that the input position has value 1 (only truthy value)
                 # generate the outputs
Z                # take the maximum of the distances
 F               # iterate that many times:
  D              #   duplicate the distance list
   ®             #   push the keyboard string
    s            #   swap to the distance list
     ÅÏ }        #   apply where truthy (==1)
       u         #     uppercase
         19ô     #   split into groups of 19
            »    #   join by newlines
             ,   #   print
              ¶? #   print a newline
                <#   decrement distance list
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 64 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“¤Äı’b3’s2
+Ɱ¢ẎfØqŒṪ¤Q
ḢØqœiWÇƬḟ"ṖẎ$Ƥ$LƇœịØqżŒu$µyⱮØqK€2Żẋ@⁶¤;")
```
A monadic Link accepting a list of 1 character which yields a list of keyboards, each keyboard being a list of lists of characters (including the spacing given in the examples).
**[Try it online!](https://tio.run/##y0rNyan8//9Rw5xDSw63HNn4qGFmkjGQKDbi0n60cd2hRQ939aUdnlF4dNLDnasOLQnkerhjEYg7OTP8cPuxNQ93zFd6uHMaUJHKsSUqPsfaj05@uLsbpGDP0UmlKoe2VgINAXK9HzWtMTq6@@GubodHjdsOLbFW0vx/uD0SKJr1qHHfoW2Htv3/XwIA "Jelly – Try It Online")** (Footer joins the resulting keyboards with newline characters and joins the result with pairs of newline characters to display like the examples.)
]